diff --git a/.changeset/eql-v3-ffi-0-28-concrete-types.md b/.changeset/eql-v3-ffi-0-28-concrete-types.md new file mode 100644 index 00000000..8ee56528 --- /dev/null +++ b/.changeset/eql-v3-ffi-0-28-concrete-types.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/stack': minor +--- + +Upgrade `@cipherstash/protect-ffi` to 0.28.0 and update EQL v3 concrete Postgres domain names to match the SQL fixture (`integer*`, `smallint*`, `bool`, `real*`, and `double*`). The public factories remain semantic (`Integer`, `Smallint`, `Boolean`, `Real`, `Double`) while their concrete domains change, so this is a minor release. diff --git a/.changeset/eql-v3-public-domains.md b/.changeset/eql-v3-public-domains.md new file mode 100644 index 00000000..65659d4c --- /dev/null +++ b/.changeset/eql-v3-public-domains.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/stack': patch +--- + +Re-vendor the EQL v3 SQL bundle and align the v3 DSL to it: encrypted type domains now live in the `public` schema (`public.text`, `public.integer`, …) rather than `eql_v3`, and the boolean domain is `public.boolean` (was `eql_v3.bool`). The `eql_v3` schema now holds only the operator-backing functions, and the index-term constructors (`hmac_256`, `ore_block_256`, `bloom_filter`) moved to `eql_v3_internal`. This keeps the SDK's emitted domain names byte-matched to the installed bundle so `CREATE TABLE`/cast resolution succeeds. diff --git a/.changeset/eql-v3-typed-client.md b/.changeset/eql-v3-typed-client.md index 82949cc6..884b2ad8 100644 --- a/.changeset/eql-v3-typed-client.md +++ b/.changeset/eql-v3-typed-client.md @@ -11,19 +11,19 @@ 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`, `timestamp → Date`, …). + (`text → string`, `timestamp → 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`. + reconstructing `Date` 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` +as the base client; only the model-decrypt paths add a per-column `Date` 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 index 67fe4e61..780e562d 100644 --- a/.changeset/eql-v3-typed-schema.md +++ b/.changeset/eql-v3-typed-schema.md @@ -2,6 +2,6 @@ '@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.Timestamp`), including explicit query capability metadata (`getQueryCapabilities()` / `isQueryable()`) and v3 table support in model encryption helpers (`encryptModel` / `bulkEncryptModels`). +Add EQL v3 schema builders for supported generated SQL domains under `@cipherstash/stack/eql/v3`, exposed as the `types` namespace (one member per supported EQL v3 domain, e.g. `types.TextEq` / `types.IntegerOrd` / `types.Timestamp`), 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` / `timestamp` / `int8` domains can be encrypted and queried with their natural JavaScript values. +Also widen the accepted plaintext input type for `encrypt` / `encryptQuery` to include `Date` (via the new `Plaintext` type), so v3 `date` / `timestamp` domains can be encrypted and queried with their natural JavaScript values. diff --git a/.changeset/skip-v3-bigint.md b/.changeset/skip-v3-bigint.md new file mode 100644 index 00000000..481574a7 --- /dev/null +++ b/.changeset/skip-v3-bigint.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/stack': patch +--- + +Omit EQL v3 bigint factories from the public DSL and test matrix until native bigint round-tripping is supported. diff --git a/.github/actions/require-cs-secrets/action.yml b/.github/actions/require-cs-secrets/action.yml new file mode 100644 index 00000000..55b39f1d --- /dev/null +++ b/.github/actions/require-cs-secrets/action.yml @@ -0,0 +1,43 @@ +name: Require CipherStash secrets +description: >- + Fail the job when any CS_* credential is missing. The live test suites gate + themselves on these vars (vitest `describe.skip`, Deno `test.ignore`), so a + rotated / cleared / fork-PR-absent secret would make them silently skip and + let CI go green with ZERO live coverage. This turns that silent skip into a + loud failure. Requires the repo to be checked out first (local action path). + +inputs: + workspace-crn: + description: secrets.CS_WORKSPACE_CRN + required: true + client-id: + description: secrets.CS_CLIENT_ID + required: true + client-key: + description: secrets.CS_CLIENT_KEY + required: true + client-access-key: + description: secrets.CS_CLIENT_ACCESS_KEY + required: true + +runs: + using: composite + steps: + - name: Assert CS_* secrets are present + shell: bash + env: + CS_WORKSPACE_CRN: ${{ inputs.workspace-crn }} + CS_CLIENT_ID: ${{ inputs.client-id }} + CS_CLIENT_KEY: ${{ inputs.client-key }} + CS_CLIENT_ACCESS_KEY: ${{ inputs.client-access-key }} + run: | + missing=0 + for v in CS_WORKSPACE_CRN CS_CLIENT_ID CS_CLIENT_KEY CS_CLIENT_ACCESS_KEY; do + if [ -z "${!v}" ]; then + echo "::error::Required secret $v is not set on this runner — live test suites would silently skip." + missing=1 + fi + done + if [ "$missing" -ne 0 ]; then + exit 1 + fi diff --git a/.github/workflows/prisma-example-readme-e2e.yml b/.github/workflows/prisma-example-readme-e2e.yml index 0b642213..954b0b82 100644 --- a/.github/workflows/prisma-example-readme-e2e.yml +++ b/.github/workflows/prisma-example-readme-e2e.yml @@ -65,6 +65,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # A missing / rotated / fork-PR-absent secret makes the walkthrough skip + # its live steps silently, hiding regressions behind a green job. Fail loud. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Build via turbo so `^build` on `@cipherstash/prisma-next` and # its `@cipherstash/stack` peer is honoured. The test's # `pnpm install` subprocess inside `examples/prisma/` is a no-op diff --git a/.github/workflows/prisma-next-e2e.yml b/.github/workflows/prisma-next-e2e.yml index 00d63c01..abc7ff82 100644 --- a/.github/workflows/prisma-next-e2e.yml +++ b/.github/workflows/prisma-next-e2e.yml @@ -67,6 +67,17 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # The global-setup hook hard-errors without CS_WORKSPACE_CRN, but a + # missing sibling secret could still degrade coverage silently — assert + # all four up front so a rotated / fork-PR-absent secret fails loudly. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Write the CS_* credentials and the harness DATABASE_URL into the # example app's .env so the runtime + the `prisma-next migration # apply` invocation in global-setup both pick them up. The harness diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 0468face..b2b215e1 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -59,6 +59,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # Fail loudly if any live-test credential is missing, so the v3 live + # matrix (and every other `describeLive` suite) can't silently skip. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + - name: Type tests (stack) run: pnpm --filter @cipherstash/stack run test:types @@ -152,6 +162,16 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + # Auth-dependent `e2e/` suites skip themselves without these vars — a + # silent skip would hide regressions behind a green job. Fail loudly. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} + # Run the standalone `e2e/` workspace via turbo so the `^build` # dep on the `test:e2e` task builds cli + wizard first. CLI's own # E2E (`packages/cli/tests/e2e/**`) is covered by the `run-tests` @@ -219,19 +239,17 @@ jobs: - name: Build stack run: pnpm exec turbo run build --filter @cipherstash/stack - # roundtrip.test.ts skips itself (Deno.test.ignore) when any of - # the four CS_* env vars is missing — that's the right behaviour - # for local runs, but in CI a silent skip would mean a rotated / - # cleared secret hides a real WASM regression behind a green job. - # Fail loudly instead. - - name: Assert CS_* secrets are present - run: | - for v in CS_WORKSPACE_CRN CS_CLIENT_ID CS_CLIENT_KEY CS_CLIENT_ACCESS_KEY; do - if [ -z "${!v}" ]; then - echo "::error::Required secret $v is not set on this runner — the WASM smoke test would silently skip." - exit 1 - fi - done + # roundtrip.test.ts skips itself (Deno.test.ignore) when any of the four + # CS_* env vars is missing — fine locally, but in CI a silent skip would + # let a rotated / cleared secret hide a real WASM regression behind a + # green job. Fail loudly instead. + - name: Require CipherStash secrets + uses: ./.github/actions/require-cs-secrets + with: + workspace-crn: ${{ secrets.CS_WORKSPACE_CRN }} + client-id: ${{ secrets.CS_CLIENT_ID }} + client-key: ${{ secrets.CS_CLIENT_KEY }} + client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }} - name: Run Deno WASM smoke test working-directory: e2e/wasm diff --git a/docs/eql-v3-ord-term-ordering-defect.md b/docs/eql-v3-ord-term-ordering-defect.md new file mode 100644 index 00000000..54b52e65 --- /dev/null +++ b/docs/eql-v3-ord-term-ordering-defect.md @@ -0,0 +1,135 @@ +# EQL v3 non-superuser limitation: `ORDER BY eql_v3.ord_term(col)` does not sort in ORE order + +**Status:** Root-caused with live evidence. This is **not** a bug in our SDK and +not a defect in the EQL bundle — it is a **known platform limitation** of the +current (ORE-based) vendored EQL v3 bundle on non-superuser Postgres +(e.g. Supabase). The superuser gate on the ORE operator class is an intentional +install constraint so the bundle installs at all on managed Postgres, where an +ORE ordered index genuinely cannot exist. Our tests/docs are corrected to stop +relying on the construct that is silently wrong in that state; the resolution +(an upstream `_ord`→OPE migration) is tracked as a follow-up (see +[Resolution](#resolution)). + +## Summary + +For an encrypted ordering column (any `*_ord` / `text_search` domain), the range +comparison functions `eql_v3.gte`/`lte`/`lt`/`gt` sort **correctly** (true ORE +order), but on a non-superuser install `ORDER BY eql_v3.ord_term(col)` sorts +**incorrectly** — deterministic but not the ORE/lexical order. + +Reproduced against live Postgres (role `is_superuser = off`) with emails +`ada@example.com`, `grace@example.com`, `alan@example.net`, `zora@example.org`: + +| Construct | Result | Correct? | +|---|---|---| +| pairwise `eql_v3.lt(col, col)` (the ORE comparator) | `ada < alan < grace < zora` | ✅ ORE/lexical | +| `ORDER BY eql_v3.ord_term(col)` | `zora, alan, ada, grace` | ❌ record_ops | +| `ORDER BY col` (domain default) | `grace, ada, alan, zora` (structural) | ❌ jsonb_ops | +| `ORDER BY col USING <` / `USING OPERATOR(public.<)` | error: *operator < is not a valid ordering operator* | ❌ no orderable family | + +So on a non-superuser install there is **no** `ORDER BY` construct that yields +ORE order. Only the boolean comparison operators (used in `WHERE` predicates) are +ORE-correct — and they are correct regardless of superuser. + +## Why this happens on Supabase + +File: `packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql` +(the vendored bundle — do not hand-edit; it is regenerated on re-vendor). + +1. `eql_v3.ord_term(a public.text_search)` (and every `*_ord` domain, e.g. + `public.integer_ord` at line 18117) returns the **composite** type + `eql_v3_internal.ore_block_256` — line **38141-38144**: + ```sql + CREATE FUNCTION eql_v3.ord_term(a public.text_search) + RETURNS eql_v3_internal.ore_block_256 ... + ``` + `ore_block_256` is `CREATE TYPE ... AS (terms eql_v3_internal.ore_block_256_term[])` + at line **193**. + +2. The ORE-correct default btree opclass for that composite type, + `eql_v3_internal.ore_block_256_operator_class` (backed by + `eql_v3_internal.compare_ore_block_256_terms`), is created inside a + superuser-gated `DO` block — lines **3117-3138**. Creating an operator + class requires superuser, so on managed/non-superuser Postgres it is + **intentionally skipped** on `insufficient_privilege` (lines 3134-3136): + ``` + EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class + (requires superuser); ORE ordered indexes on ore_block_256 unavailable ... + ``` + This gate is deliberate: it is what lets the EQL v3 bundle install cleanly on + Supabase and other non-superuser platforms, where an ORE ordered index cannot + exist at all. Live check confirms: + `SELECT ... FROM pg_opclass ... WHERE typname='ore_block_256'` returns `[]`. + +3. With the opclass absent, `ORDER BY eql_v3.ord_term(col)` still "works" + because PostgreSQL supplies a built-in **record comparison** for any + composite type. That compares the `ore_block_256_term[]` fields by their raw + bytes — deterministic, but unrelated to ORE order. This is the silent-wrong + footgun: it does not error, it just sorts wrong. + +4. Meanwhile `eql_v3.gte/lte/lt/gt` are ORE-correct **regardless of superuser** + because they do not go through index/sort machinery. `eql_v3.lt(text_search)` + (line 38206) is `SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)`, and the + `public.<` operator on `ore_block_256` is wired directly to + `eql_v3_internal.compare_ore_block_256_terms`. The domain-level `<` operator + (`CREATE OPERATOR <`, line 38566, `FUNCTION = eql_v3.lt`) exists, but it is + **not** a member of any btree operator family, so `ORDER BY col USING <` + raises "operator < is not a valid ordering operator". + +The bundle comment (lines 3104-3114) documents the missing opclass as the +accepted managed-Postgres limitation ("ORE ordered scans ... unavailable"). The +practical consequence to be aware of is that `ORDER BY ord_term(col)` **silently +returns wrong results** in that state instead of failing, and there is no +non-superuser ORE ordering path on the current bundle. + +## Minimal repro + +```sql +-- role without superuser; EQL v3 bundle installed +CREATE TABLE t (email public.text_search NOT NULL, label text); +-- insert encrypted 'ada@example.com','grace@example.com', +-- 'alan@example.net','zora@example.org' (labels ada/grace/alan/zora) + +SELECT current_setting('is_superuser'); -- off +SELECT count(*) FROM pg_opclass c JOIN pg_type ty + ON ty.oid=c.opcintype WHERE ty.typname='ore_block_256'; -- 0 + +SELECT label FROM t ORDER BY eql_v3.ord_term(email); -- zora,alan,ada,grace (WRONG) +-- vs the ORE comparator, which is correct: +SELECT x.label, y.label, eql_v3.lt(x.email, y.email) FROM t x CROSS JOIN t y; -- ada eql_v3.ord_term(col)` for a future v3 + Drizzle/Prisma adapter (e.g. + `docs/superpowers/2026-06-12-eql-v3-drizzle-adapter-walkthrough.md`, + `docs/superpowers/plans/2026-07-06-eql-v3-drizzle-concrete-types.md`) would hit + this limitation on the current ORE bundle if implemented as written. Any v3 + `orderBy` must not lower to a bare `ORDER BY ord_term(...)` on the current ORE + bundle; once the OPE `_ord` migration lands, `ORDER BY` on `_ord` becomes + correct everywhere. diff --git a/e2e/wasm/deno.json b/e2e/wasm/deno.json index 47901fe8..e35ddcfd 100644 --- a/e2e/wasm/deno.json +++ b/e2e/wasm/deno.json @@ -3,13 +3,34 @@ "//2": "stack is imported via a file URL because the wasm-inline subpath isn't on a published version yet — once stack ships with /wasm-inline this can switch to a plain npm: specifier. protect-ffi and auth resolve via npm: against the workspace's installed versions (Deno's nodeModulesDir: auto lets it use what pnpm fetched).", "//3": "No --allow-ffi grant. If protect-ffi ever silently fell back to a native binding under Deno, the test would fail on missing FFI permission — this is the WASM guarantee.", "nodeModulesDir": "auto", + "//4": "Deno 2.9+ enforces a 24h minimumDependencyAge cooldown by default. Mirror pnpm-workspace.yaml's supply-chain policy (minimumReleaseAge: 7d + minimumReleaseAgeExclude) so the two toolchains agree: keep the 7-day cooldown for third-party deps, but exempt the first-party CipherStash packages this test imports — they ship on their own cadence and are bumped in lockstep. Without the exclude, a just-published protect-ffi/auth (e.g. 0.28.0) fails resolution until it ages past the window.", + "//5": "Deno's exclude does not support globs, so the per-platform native binary sub-packages (optional deps published in lockstep at the same version) are enumerated explicitly — mirrors pnpm-workspace.yaml's protect-ffi-* / auth-* wildcards.", + "minimumDependencyAge": { + "age": "P7D", + "exclude": [ + "npm:@cipherstash/protect-ffi", + "npm:@cipherstash/protect-ffi-darwin-arm64", + "npm:@cipherstash/protect-ffi-darwin-x64", + "npm:@cipherstash/protect-ffi-linux-arm64-gnu", + "npm:@cipherstash/protect-ffi-linux-x64-gnu", + "npm:@cipherstash/protect-ffi-linux-x64-musl", + "npm:@cipherstash/protect-ffi-win32-x64-msvc", + "npm:@cipherstash/auth", + "npm:@cipherstash/auth-darwin-arm64", + "npm:@cipherstash/auth-darwin-x64", + "npm:@cipherstash/auth-linux-arm64-gnu", + "npm:@cipherstash/auth-linux-x64-gnu", + "npm:@cipherstash/auth-linux-x64-musl", + "npm:@cipherstash/auth-win32-x64-msvc" + ] + }, "tasks": { "//task": "--no-check because TypeScript can't infer the column-on-table intersection types when stack is loaded via file URL (the dist .d.ts strips brand info). This test exists to verify RUNTIME WASM round-trips — type narrowing is covered by the package's own vitest suite.", "test": "deno test --no-check --allow-env --allow-net --allow-read --allow-sys --no-prompt" }, "imports": { "@cipherstash/stack/wasm-inline": "../../packages/stack/dist/wasm-inline.js", - "@cipherstash/protect-ffi/wasm-inline": "npm:@cipherstash/protect-ffi@0.26.0/wasm-inline", + "@cipherstash/protect-ffi/wasm-inline": "npm:@cipherstash/protect-ffi@0.28.0/wasm-inline", "@cipherstash/auth/wasm-inline": "npm:@cipherstash/auth@0.40.0/wasm-inline" } } diff --git a/packages/stack/__tests__/cjs-require.test.ts b/packages/stack/__tests__/cjs-require.test.ts index c91f11ee..0b530fd5 100644 --- a/packages/stack/__tests__/cjs-require.test.ts +++ b/packages/stack/__tests__/cjs-require.test.ts @@ -93,7 +93,7 @@ describe('CJS consumers can require the built bundles', () => { `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', 'Int4Ord', 'Bool', 'Timestamp']`, + `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') diff --git a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts index 68fa4e65..c610d608 100644 --- a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts +++ b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts @@ -40,7 +40,7 @@ const users = encryptedTable('users', { }) const usersV3 = encryptedTableV3('users_v3', { - score: types.Int4Ord('score'), + score: types.IntegerOrd('score'), }) // biome-ignore lint/suspicious/noExplicitAny: test helper reads the Result union diff --git a/packages/stack/__tests__/error-codes.test.ts b/packages/stack/__tests__/error-codes.test.ts index 80ecbc0f..ad1c7de4 100644 --- a/packages/stack/__tests__/error-codes.test.ts +++ b/packages/stack/__tests__/error-codes.test.ts @@ -5,6 +5,7 @@ import type { EncryptionClient } from '@/encryption' import { EncryptionErrorTypes } from '@/errors' import { Encryption } from '@/index' import { encryptedColumn, encryptedTable } from '@/schema' +import type { BulkDecryptPayload } from '@/types' /** FFI tests require longer timeout due to client initialization */ const FFI_TEST_TIMEOUT = 30_000 @@ -246,26 +247,30 @@ 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', async () => { - // bulkDecrypt uses the "fallible" FFI API (decryptBulkFallible) which normally: - // - 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. + // bulkDecrypt uses the fallible FFI API, so malformed items are + // reported per item instead of failing the whole operation. const invalidCiphertexts = [ { data: { i: { t: 'test_table', c: 'email' }, v: 2, c: 'invalid1' } }, { data: { i: { t: 'test_table', c: 'email' }, v: 2, c: 'invalid2' } }, - ] + ] as unknown as BulkDecryptPayload 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() + if (result.failure) { + throw new Error( + `Expected per-item errors, got ${result.failure.type}`, + ) + } + + expect(result.data).toHaveLength(2) + expect(result.data.every((item) => 'error' in item)).toBe(true) + + for (const item of result.data) { + expect(item.error).toBeDefined() + expect('code' in item).toBe(false) + } }, 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 index fc2f9325..56a59e03 100644 --- a/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql +++ b/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql @@ -1,18 +1,38 @@ --! @file v3/schema.sql --! @brief EQL v3 schema creation --! ---! Creates the eql_v3 schema, which houses the self-contained encrypted-domain ---! type families (eql_v3.int4, eql_v3.int8, and future scalar domains): their ---! jsonb-backed domains, the searchable-encrypted-metadata (SEM) index-term ---! types they use (eql_v3.hmac_256, eql_v3.ore_block_256), the index-term ---! extractors, comparison wrappers, blockers, and aggregates. The v3 surface is ---! self-contained — it owns every type it needs and has no runtime dependency ---! on another EQL schema. +--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted +--! domains (public.integer, public.bigint, and future scalar domains) live in +--! public so application tables survive EQL schema uninstall. eql_v3 is the +--! public API for 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 @@ -22,6 +42,133 @@ DROP SCHEMA IF EXISTS eql_v3 CASCADE; --! @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/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 plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller +--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` — +--! both reached exclusively from plpgsql and btree operator-class support +--! contexts, where SQL functions can NEVER be inlined and instead pay the +--! per-call SQL-function executor (measured 3.5x the per-call cost of the +--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql +--! caches its plan across calls. The non-array guard preserves the v3 +--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original +--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`), +--! so the divergence stays 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 $$ +DECLARE + result bytea[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(decode(value::text, 'hex')::bytea) + INTO result + FROM jsonb_array_elements_text(val) AS value; + RETURN result; +END; +$$ LANGUAGE plpgsql; + +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! 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 opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; +-- 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 DEV 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: `SELECT eql_v3.version()` returns the installed version string, +--! e.g. `'3.0.0'` (or `'DEV'` for development builds). +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT 'DEV'; +$$ 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 'DEV'; + --! @file v3/sem/ore_block_256/types.sql --! @brief ORE block index-term types (eql_v3 SEM). --! @@ -32,7 +179,7 @@ CREATE SCHEMA eql_v3; --! --! Composite type representing a single ORE block term. Stores encrypted data --! as bytea that enables range comparisons without decryption. -CREATE TYPE eql_v3.ore_block_256_term AS ( +CREATE TYPE eql_v3_internal.ore_block_256_term AS ( bytes bytea ); @@ -43,109 +190,62 @@ CREATE TYPE eql_v3.ore_block_256_term AS ( --! in the 'ob' field of encrypted data payloads. --! --! @note Transient type used only during query execution. -CREATE TYPE eql_v3.ore_block_256 AS ( - terms eql_v3.ore_block_256_term[] +CREATE TYPE eql_v3_internal.ore_block_256 AS ( + terms eql_v3_internal.ore_block_256_term[] ); ---! @file v3/crypto.sql ---! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! @file v3/sem/ope_cllw/types.sql +--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) --! ---! 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. +--! 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. --! ---! 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. +--! 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 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'; +--! @note Transient type used only during query execution. +--! @see eql_v3_internal.ope_cllw +CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; - 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/sem/ope_cllw/functions.sql +--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). ---! @file v3/common.sql ---! @brief Common utility functions for the self-contained eql_v3 surface. +--! @brief Extract CLLW OPE index term from JSONB payload --! ---! 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 +--! 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. --! ---! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. ---! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! 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. --! ---! @param val jsonb JSONB array of hex-encoded strings ---! @return bytea[] Array of decoded binary values +--! **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. --! ---! @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.jsonb_array_to_bytea_array(val jsonb) -RETURNS bytea[] - IMMUTABLE +--! @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 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; + SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw +$$; ---! @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.jsonb_array_to_bytea_array(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; +COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; --! @file v3/sem/hmac_256/types.sql --! @brief HMAC-SHA256 index term type (eql_v3 SEM) @@ -156,1841 +256,12336 @@ COMMENT ON FUNCTION eql_v3.jsonb_array_to_bytea_array(jsonb) IS --! unchanged. --! --! @note Transient type used only during query execution. -CREATE DOMAIN eql_v3.hmac_256 AS text; +CREATE DOMAIN eql_v3_internal.hmac_256 AS text; + +--! @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/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.text_match`. The +--! 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.bloom_filter AS smallint[]; +CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; ---! @file v3/scalars/functions.sql ---! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! @file v3/sem/bloom_filter/functions.sql +--! @brief Extractor for the eql_v3 Bloom-filter SEM index term. --! ---! Per-domain wrapper functions live in src/v3/scalars//. ---! Blockers in those files delegate to encrypted_domain_unsupported_bool ---! so every domain raises a uniform domain-specific error rather than ---! letting an unsupported operator fall through to native jsonb ---! behaviour. +--! 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 Shared blocker helper. Raises 'operator X is not supported ---! for TYPE' so unsupported domain operators surface a clear ---! error rather than fall through to native jsonb behaviour. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (=, <, @>, ->, etc.) ---! @return boolean (never returns; always raises) -CREATE FUNCTION eql_v3.encrypted_domain_unsupported_bool(type_name text, operator_name text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public +--! @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 - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; + BEGIN + RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; + END; $$ LANGUAGE plpgsql; ---! @brief Shared blocker helper returning jsonb. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! native operators whose result is jsonb (#>, -, #-, ||), so composed ---! expressions resolve and the body raises rather than failing earlier ---! with a misleading 'operator does not exist' on a boolean result. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>, -, #-, ||, etc.) ---! @return jsonb (never returns; always raises) -CREATE FUNCTION eql_v3.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public +--! @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 $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; + SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' + THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter + END +$$; ---! @brief Shared blocker helper returning text. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! the native #>> operator whose result is text. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>>) ---! @return text (never returns; always raises) -CREATE FUNCTION eql_v3.encrypted_domain_unsupported_text(type_name text, operator_name text) -RETURNS text -IMMUTABLE PARALLEL SAFE +--! @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 + -- User-column encrypted domains now live in public so application tables + -- survive EQL uninstall. Keep this separate from owned_schemas(): public is + -- not installer-owned, but its EQL jsonb-backed domains are still the domain + -- types whose blockers/operator surfaces the lint must understand. + encrypted_domain_types AS ( + SELECT + dt.oid AS typid + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND bn.nspname = 'pg_catalog' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ), + + -- All operators where at least one operand is an EQL-owned type or a public + -- encrypted domain. Limits the scope of the lint to the operator surface + -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). + eql_operators AS ( + SELECT + op.oid AS oprid, + op.oprname AS opname, + op.oprcode AS implfunc, + op.oprleft::regtype AS lhs, + op.oprright::regtype AS rhs, + op.oprcode::regprocedure AS impl_signature + FROM pg_operator op + WHERE EXISTS ( + SELECT 1 FROM pg_type t + WHERE t.oid IN (op.oprleft, op.oprright) + AND ( + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + OR t.oid IN (SELECT typid FROM encrypted_domain_types) + ) + ) + ), + + -- 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 encrypted domain over jsonb argument. The argument + -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` + -- helpers themselves, which contain the marker in their body but are not + -- blockers (they take text arguments, not a domain). + encrypted_domain_blockers AS ( + SELECT + p.oid AS oid, + p.oid::regprocedure::text AS signature, + lang_l.lanname AS lang, + p.proisstrict AS isstrict + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND (p.prosrc LIKE '%encrypted_domain_unsupported%' + OR p.prosrc LIKE '%is not supported for%') + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN encrypted_domain_types edt ON edt.typid = arg.typ + ) + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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 bt.oid IN (SELECT typid FROM encrypted_domain_types) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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.oid IN (SELECT typid FROM encrypted_domain_types) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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/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 +); + +--! @file v3/scalars/functions.sql +--! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! +--! Per-domain wrapper functions live in src/v3/scalars//. +--! Blockers in those files delegate to encrypted_domain_unsupported_bool +--! so every domain raises a uniform domain-specific error rather than +--! letting an unsupported operator fall through to native jsonb +--! behaviour. + +--! @brief Shared blocker helper. Raises 'operator X is not supported +--! for TYPE' so unsupported domain operators surface a clear +--! error rather than fall through to native jsonb behaviour. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (=, <, @>, ->, etc.) +--! @return boolean (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning jsonb. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! native operators whose result is jsonb (#>, -, #-, ||), so composed +--! expressions resolve and the body raises rather than failing earlier +--! with a misleading 'operator does not exist' on a boolean result. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>, -, #-, ||, etc.) +--! @return jsonb (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning text. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! the native #>> operator whose result is text. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>>) +--! @return text (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/types.sql +--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! Three jsonb-backed domains (none over another domain — operators resolve +--! against the ultimate base type jsonb, so the native-jsonb firewall in +--! blockers.sql can attach): +--! - public.json — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.jsonb_entry — a single sv element (returned by `->`). +--! - public.jsonb_query — a containment needle (sv elements, no ciphertext). + +--! @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 OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? '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`). +--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the +--! public.jsonb_query domain CHECK, where a SQL function can never be +--! inlined (and the CHECK itself cannot absorb this body — it needs a +--! subquery over the sv elements, which CHECK constraints forbid). plpgsql +--! caches its plan across calls instead of paying the per-call SQL-function +--! executor on every needle cast. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +AS $$ +BEGIN + RETURN COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ); +END; +$$; + +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 3`, `i`, an `sv` array, and valid sv entry elements. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND val ? 'v' + AND val ->> 'v' = '3' + AND val ? 'i' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; + +--! @brief Storage/root domain for an encrypted JSONB column. +--! +--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index +--! metadata). Root `c` is intentionally NOT required — an sv-array root payload +--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` +--! array, so the domain accepts only SteVec **document** payloads and rejects +--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is +--! what keeps `public.json` a typed document domain rather than a generic +--! encrypted envelope. The firewall in blockers.sql attaches to this domain to +--! stop native jsonb operators from reaching a column value. +--! +--! @note Constructing from inline JSON uses the standard DOMAIN cast: +--! `'{"i":{},"v":3,"sv":[...]}'::public.json`. +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'json' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.json AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN public.json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; +END +$$; + +--! @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 +--! +--! @internal +--! Implementation note (issue #354): the CHECK is an INLINE expression, not a +--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! constraints cannot inline SQL functions, so the function-call form paid +--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle +--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured +--! regression on that scenario; see cipherstash/benches#23). The expression +--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the +--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) +--! would reject NULL, which `->` returns for a missing selector). Keep the +--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins +--! the equivalence. +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'jsonb_entry' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.jsonb_entry AS jsonb + CHECK ( + VALUE IS NULL + OR COALESCE( + jsonb_typeof(VALUE) = 'object' + AND jsonb_typeof(VALUE -> 's') = 'string' + AND jsonb_typeof(VALUE -> 'c') = 'string' + AND ( + (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'oc')) + OR + (jsonb_typeof(VALUE -> 'oc') = 'string' AND NOT (VALUE ? 'hm')) + ), + false + ) + ); + END IF; + + COMMENT ON DOMAIN public.jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; +END +$$; + +--! @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":"","hm":""}]}'::public.jsonb_query`. +--! @see eql_v3.to_ste_vec_query +--! +--! @internal +--! Implementation note (issue #354): this CHECK CANNOT be inlined like +--! public.jsonb_entry's — validating the sv elements requires a subquery +--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK +--! constraints forbid subqueries. The validator is plpgsql instead (cached +--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql +--! function — the same finding as issue #353), since this cast sits on the +--! per-query hot path of every containment scenario +--! (`$1::jsonb::public.jsonb_query`). +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'jsonb_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.jsonb_query AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN public.jsonb_query IS 'EQL JSONB query operand (containment)'; +END +$$; + +--! @brief Convert a public.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 public.json Source encrypted payload +--! @return public.jsonb_query Query-shaped needle, sv elements normalised. +--! @see public.jsonb_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.json) + RETURNS public.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 + ) + )::public.jsonb_query +$$; + +CREATE CAST (public.json AS public.jsonb_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @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/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 plpgsql, not `LANGUAGE sql` (issue #353). The sole caller +--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached +--! from an inlinable context — as `LANGUAGE sql` it paid the per-call +--! SQL-function executor on every compared value in the opclass hot path +--! (measured: +43% on ORE ordered scans vs the plpgsql form). The +--! non-array guard preserves the v3 behaviour (returns NULL for a +--! non-array scalar; the v2 plpgsql original raised); the caller only +--! reaches this when `has_ore_block_256(val)` is true, which requires +--! `val->'ob'` to be a JSON array, so that branch stays unreachable. +--! 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 $$ +DECLARE + terms eql_v3_internal.ore_block_256_term[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + INTO terms + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b; + -- plpgsql pitfall: `SELECT INTO ` assigns the + -- select-list columns FIELD-WISE into the variable — return the row + -- constructor directly instead. The COALESCE stays load-bearing for the + -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and + -- the comparator needs an EMPTY terms array, not NULL terms. + RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256; +END; +$$ LANGUAGE plpgsql; + +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! 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 opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; + + +--! @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/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; + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for public.json. +--! +--! public.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.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 public.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 public.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('public.json', '?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists, + LEFTARG = public.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a public.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 public.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('public.json', '?|'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a public.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 public.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('public.json', '?&'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: @? (jsonpath exists). +--! @param a public.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 public.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('public.json', '@?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = public.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: @@ (jsonpath predicate). +--! @param a public.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 public.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('public.json', '@@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, + LEFTARG = public.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: #> (path extract, native returns jsonb). +--! @param a public.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 public.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('public.json', '#>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #>> (path extract as text). +--! @param a public.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 public.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('public.json', '#>>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: - (delete key, text RHS; native returns jsonb). +--! @param a public.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 public.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('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, + LEFTARG = public.json, + RIGHTARG = text +); + +--! @brief Blocker: - (delete index, integer RHS). +--! @param a public.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 public.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('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, + LEFTARG = public.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a public.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 public.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('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a public.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 public.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('public.json', '#-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a public.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 public.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('public.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b public.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 public.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root public.json document comparisons. +--! @param a public.json Left operand (encrypted payload). +--! @param b public.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 public.json, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root public.json-to-jsonb comparisons. +--! @param a public.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 public.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('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root jsonb-to-public.json comparisons. +--! @param a jsonb Native LHS operand. +--! @param b public.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 public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a public.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 public.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('public.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: @> with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b public.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 public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with encrypted root document and native jsonb. +--! @param a public.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 public.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('public.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b public.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 public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +--! @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 +); + +--! @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 public.jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry public.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 public.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 public.jsonb_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry public.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 public.jsonb_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry public.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 public.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 public.jsonb_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry public.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 +--! `public.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 +--! `public.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::public.jsonb_entry) = eql_v3.eq_term(b::public.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 public.json Container. +--! @param b public.json Elements to find. +--! @return boolean True if all elements of b are contained in a. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.json, b public.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 +--! public.json document, because the root document domain requires an `sv` +--! array and single leaves belong to public.jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF public.jsonb_entry Matching encrypted entries. +--! @see eql_v3.jsonb_path_query_first +CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.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 public.jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.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 public.jsonb_entry One row per element (metadata preserved). +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) + RETURNS SETOF public.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)::public.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; + +--! @file v3/jsonb/aggregates.sql +--! @brief min / max aggregates over public.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 public.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 public.jsonb_entry Running extremum. +--! @param value public.jsonb_entry Candidate entry. +--! @return public.jsonb_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state public.jsonb_entry, + value public.jsonb_entry +) +RETURNS public.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 public.jsonb_entry. +--! @param input public.jsonb_entry +--! @return public.jsonb_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(public.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = public.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.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 public.jsonb_entry Running extremum. +--! @param value public.jsonb_entry Candidate entry. +--! @return public.jsonb_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state public.jsonb_entry, + value public.jsonb_entry +) +RETURNS public.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 public.jsonb_entry. +--! @param input public.jsonb_entry +--! @return public.jsonb_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(public.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = public.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); + +--! @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 Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_cllw are unavailable, but +--! the order-preserving (OPE) ordering domains — whose extractor return +--! types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_cllw_term + +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_cllw_ops USING btree'; + + EXECUTE $ddl$ + 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) + $ddl$; + + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_cllw_ops'; +EXCEPTION + WHEN insufficient_privilege THEN + RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_cllw_ops (requires superuser); ORE ordered indexes on ore_cllw unavailable, OPE ordering domains unaffected'; +END; +$do$; + +--! @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._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/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). +--! +--! @note Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, +--! but the order-preserving (OPE) ordering domains — whose extractor +--! return types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_block_256_terms + +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; + + EXECUTE $ddl$ + CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class + DEFAULT FOR TYPE eql_v3_internal.ore_block_256 + USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS + OPERATOR 1 public.<, + OPERATOR 2 public.<=, + OPERATOR 3 public.=, + OPERATOR 4 public.>=, + OPERATOR 5 public.>, + FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) + $ddl$; + + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; +EXCEPTION + WHEN insufficient_privilege THEN + RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected'; +END; +$do$; + +--! @file v3/jsonb/operators.sql +--! @brief Operators on public.json and public.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 `public.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 public.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return public.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.json, selector text) + RETURNS public.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) + ) + )::public.jsonb_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=public.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e public.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return public.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.json, selector integer) + RETURNS public.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 `public.json` to + -- its base type and binds native `jsonb -> text` (see the @warning above) — + -- the custom `->(public.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 `->(public.json, integer)` + -- operator instead of native array access. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.jsonb_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=public.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 public.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e public.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=public.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e public.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e public.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=public.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a public.json Container. +--! @param b public.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a public.json, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.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 public.json Container. +--! @param b public.jsonb_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a public.json, b public.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=public.json, + RIGHTARG=public.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 public.json Container. +--! @param b public.jsonb_entry Single entry. +--! @return boolean True if a contains an sv entry matching b. +CREATE FUNCTION eql_v3."@>"(a public.json, b public.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=public.json, + RIGHTARG=public.jsonb_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a public.json Contained value. +--! @param b public.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a public.json, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.json, + RIGHTARG=public.json +); + +--! @brief <@ contained-by operator with an jsonb_query LHS. +--! @param a public.jsonb_query Query payload. +--! @param b public.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a public.jsonb_query, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.jsonb_query, + RIGHTARG=public.json +); + +--! @brief <@ contained-by operator with a jsonb_entry LHS. +--! @param a public.jsonb_entry Single entry. +--! @param b public.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a public.jsonb_entry, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.jsonb_entry, + RIGHTARG=public.json +); + +------------------------------------------------------------------------------ +-- jsonb_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) +$$; + +-- Intentionally no HASHES / MERGES here. PostgreSQL requires a hash-joinable +-- operator to appear in a compatible hash opfamily, and a merge-joinable +-- operator to appear as equality in a compatible btree opfamily. jsonb_entry +-- equality is based on eql_v3.eq_term(entry), not raw jsonb/domain equality, so +-- adding only the flags would be unsound. Join/group/dedup on +-- eql_v3.eq_term(doc -> ''::text) unless a jsonb_entry opfamily with +-- eq_term-compatible hash/sort semantics is added. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on jsonb_entry via eq_term. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a public.jsonb_entry, b public.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 = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a public.jsonb_entry, b public.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 = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a public.jsonb_entry, b public.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 = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a public.jsonb_entry, b public.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 = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a public.jsonb_entry, b public.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 = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_query_types.sql +--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.bigint_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.bigint_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_eq_query IS 'EQL bigint query operand (equality)'; + + --! @brief Query-operand domain public.bigint_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ore_query IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.bigint_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_query IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.bigint_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ope_query IS 'EQL bigint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint IS 'EQL encrypted bigint (storage only)'; + + --! @brief Encrypted domain public.bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_eq IS 'EQL encrypted bigint (equality)'; + + --! @brief Encrypted domain public.bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for public.bigint_eq. + +--! @brief Index extractor for public.bigint_eq. +--! @param a public.bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.bigint_eq) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.bigint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.bigint_eq) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector text +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_eq, selector text) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector integer +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_eq, selector integer) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param selector public.bigint_eq +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_eq) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param selector public.bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_eq, b public.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for public.bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_query_functions.sql +--! @brief Functions for public.bigint_eq_query. + +--! @brief Index extractor for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq +--! @param b public.bigint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq_query, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq +--! @param b public.bigint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq_query, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_query_operators.sql +--! @brief Operators for public.bigint_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for public.bigint. + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector text +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a public.bigint, selector text) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector integer +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a public.bigint, selector integer) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param selector public.bigint +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param selector public.bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint, b public.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for public.bigint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for public.bigint_ord. + +--! @brief Index extractor for public.bigint_ord. +--! @param a public.bigint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector text +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord, selector text) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector integer +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord, selector integer) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param selector public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param selector public.bigint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord, b public.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for public.bigint_ord_ope. + +--! @brief Index extractor for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector text +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ope, selector text) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector integer +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ope, selector integer) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param selector public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord_ope) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param selector public.bigint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for public.bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql +--! @brief Aggregates for public.bigint_ord_ope. + +--! @brief State function for min on public.bigint_ord_ope. +--! @param state public.bigint_ord_ope +--! @param value public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord_ope, value public.bigint_ord_ope) +RETURNS public.bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord_ope. +--! @param input public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE AGGREGATE eql_v3.min(public.bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord_ope. +--! @param state public.bigint_ord_ope +--! @param value public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord_ope, value public.bigint_ord_ope) +RETURNS public.bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord_ope. +--! @param input public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE AGGREGATE eql_v3.max(public.bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_query_functions.sql +--! @brief Functions for public.bigint_ord_ope_query. + +--! @brief Index extractor for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_query_operators.sql +--! @brief Operators for public.bigint_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for public.bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql +--! @brief Aggregates for public.bigint_ord. + +--! @brief State function for min on public.bigint_ord. +--! @param state public.bigint_ord +--! @param value public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord, value public.bigint_ord) +RETURNS public.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 public.bigint_ord. +--! @param input public.bigint_ord +--! @return public.bigint_ord +CREATE AGGREGATE eql_v3.min(public.bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord. +--! @param state public.bigint_ord +--! @param value public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord, value public.bigint_ord) +RETURNS public.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 public.bigint_ord. +--! @param input public.bigint_ord +--! @return public.bigint_ord +CREATE AGGREGATE eql_v3.max(public.bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for public.bigint_ord_ore. + +--! @brief Index extractor for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector text +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ore, selector text) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector integer +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ore, selector integer) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param selector public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord_ore) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param selector public.bigint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for public.bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for public.bigint_ord_ore. + +--! @brief State function for min on public.bigint_ord_ore. +--! @param state public.bigint_ord_ore +--! @param value public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord_ore, value public.bigint_ord_ore) +RETURNS public.bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord_ore. +--! @param input public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE AGGREGATE eql_v3.min(public.bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord_ore. +--! @param state public.bigint_ord_ore +--! @param value public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord_ore, value public.bigint_ord_ore) +RETURNS public.bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord_ore. +--! @param input public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE AGGREGATE eql_v3.max(public.bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_query_functions.sql +--! @brief Functions for public.bigint_ord_ore_query. + +--! @brief Index extractor for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_query_operators.sql +--! @brief Operators for public.bigint_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_query_functions.sql +--! @brief Functions for public.bigint_ord_query. + +--! @brief Index extractor for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_query_operators.sql +--! @brief Operators for public.bigint_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain public.boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'boolean' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.boolean AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.boolean IS 'EQL encrypted boolean (storage only)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for public.boolean. + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector text +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a public.boolean, selector text) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector integer +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a public.boolean, selector integer) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param selector public.boolean +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.boolean) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param selector public.boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.boolean, b public.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for public.boolean. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_query_types.sql +--! @brief Query-operand domains for date (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.date_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.date_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_eq_query IS 'EQL date query operand (equality)'; + + --! @brief Query-operand domain public.date_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ore_query IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain public.date_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_query IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain public.date_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ope_query IS 'EQL date query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain public.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date IS 'EQL encrypted date (storage only)'; + + --! @brief Encrypted domain public.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.date_eq IS 'EQL encrypted date (equality)'; + + --! @brief Encrypted domain public.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.date_ord IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.date_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.date_ord_ope IS 'EQL encrypted date (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for public.date_eq. + +--! @brief Index extractor for public.date_eq. +--! @param a public.date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.date_eq) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.date_eq) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector text +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.date_eq, selector text) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector integer +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.date_eq, selector integer) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param selector public.date_eq +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_eq) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param selector public.date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_eq, b public.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for public.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_query_functions.sql +--! @brief Functions for public.date_eq_query. + +--! @brief Index extractor for public.date_eq_query. +--! @param a public.date_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.date_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq +--! @param b public.date_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq_query +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq_query, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq +--! @param b public.date_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq_query +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq_query, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_query_operators.sql +--! @brief Operators for public.date_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for public.date. + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector text +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a public.date, selector text) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector integer +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a public.date, selector integer) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param selector public.date +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param selector public.date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date, b public.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for public.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for public.date_ord. + +--! @brief Index extractor for public.date_ord. +--! @param a public.date_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector text +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord, selector text) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector integer +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord, selector integer) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param selector public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param selector public.date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord, b public.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for public.date_ord_ope. + +--! @brief Index extractor for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector text +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ope, selector text) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector integer +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ope, selector integer) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param selector public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord_ope) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param selector public.date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ope, b public.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for public.date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for public.date_ord_ope. + +--! @brief State function for min on public.date_ord_ope. +--! @param state public.date_ord_ope +--! @param value public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord_ope, value public.date_ord_ope) +RETURNS public.date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; + IF value < state THEN + RETURN value; + END IF; + RETURN state; END; -$$ LANGUAGE plpgsql; +$$; ---! @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 min aggregate for public.date_ord_ope. +--! @param input public.date_ord_ope +--! @return public.date_ord_ope +CREATE AGGREGATE eql_v3.min(public.date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Convert JSONB array to ORE block composite type ---! @internal ---! @param val jsonb Array of hex-encoded ORE block terms ---! @return eql_v3.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.jsonb_array_to_ore_block_256(val jsonb) -RETURNS eql_v3.ore_block_256 - IMMUTABLE +--! @brief State function for max on public.date_ord_ope. +--! @param state public.date_ord_ope +--! @param value public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord_ope, value public.date_ord_ope) +RETURNS public.date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public AS $$ - SELECT CASE WHEN jsonb_typeof(val) = 'array' - THEN ROW(COALESCE( - ( - SELECT array_agg(ROW(b)::eql_v3.ore_block_256_term) - FROM unnest(eql_v3.jsonb_array_to_bytea_array(val)) AS b - ), - ARRAY[]::eql_v3.ore_block_256_term[] - ))::eql_v3.ore_block_256 - ELSE NULL - END; -$$ LANGUAGE sql; +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @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.jsonb_array_to_ore_block_256(jsonb) IS - 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; +--! @brief max aggregate for public.date_ord_ope. +--! @param input public.date_ord_ope +--! @return public.date_ord_ope +CREATE AGGREGATE eql_v3.max(public.date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/date/date_ord_ope_query_functions.sql +--! @brief Functions for public.date_ord_ope_query. ---! @brief Extract ORE block index term from JSONB payload ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3.ore_block_256 ORE block index term ---! @throws Exception if 'ob' field is missing -CREATE FUNCTION eql_v3.ore_block_256(val jsonb) - RETURNS eql_v3.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.has_ore_block_256(val) THEN - RETURN eql_v3.jsonb_array_to_ore_block_256(val->'ob'); - END IF; - RAISE 'Expected an ore index (ob) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +--! @brief Index extractor for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @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.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 Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/date/date_ord_ope_query_operators.sql +--! @brief Operators for public.date_ord_ope_query. ---! @brief Compare two ORE block terms using cryptographic comparison ---! @internal ---! @param a eql_v3.ore_block_256_term First ORE term ---! @param b eql_v3.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.compare_ore_block_256_term(a eql_v3.ore_block_256_term, b eql_v3.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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - left_block_size CONSTANT smallint := 16; - right_block_size CONSTANT smallint := 32; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- 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 int4 (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) +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - indicator smallint := 0; - BEGIN - IF a IS NULL AND b IS NULL THEN - RETURN 0; - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - IF a IS NULL THEN - RETURN -1; - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - IF b IS NULL THEN - RETURN 1; - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - IF bit_length(a.bytes) != bit_length(b.bytes) THEN - RAISE EXCEPTION 'Ciphertexts are different lengths'; - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - -- 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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - 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 +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - 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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - IF eq THEN - RETURN 0::integer; - END IF; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - -- Hash key is the IV from the right CT of b. - hash_key := substr(b.bytes, right_offset + 1, 16); +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. - -- 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); +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for public.date_ord. - data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - indicator := ( - get_bit( - encrypt_block, - 0 - ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - IF indicator = 1 THEN - RETURN 1::integer; - ELSE - RETURN -1::integer; - END IF; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Compare arrays of ORE block terms recursively ---! @internal ---! @param a eql_v3.ore_block_256_term[] First array ---! @param b eql_v3.ore_block_256_term[] Second array ---! @return integer -1/0/1, or NULL if either array is NULL -CREATE FUNCTION eql_v3.compare_ore_block_256_terms(a eql_v3.ore_block_256_term[], b eql_v3.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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - IF cardinality(a) = 0 AND cardinality(b) = 0 THEN - RETURN 0; - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN - RETURN -1; - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN - RETURN 1; - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - cmp_result := eql_v3.compare_ore_block_256_term(a[1], b[1]); +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - IF cmp_result = 0 THEN - RETURN eql_v3.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - RETURN cmp_result; - END -$$ LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Compare ORE block composite types ---! @internal ---! @param a eql_v3.ore_block_256 First ORE block ---! @param b eql_v3.ore_block_256 Second ORE block ---! @return integer -1/0/1 -CREATE FUNCTION eql_v3.compare_ore_block_256_terms(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS integer - IMMUTABLE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN eql_v3.compare_ore_block_256_terms(a.terms, b.terms); - END -$$ LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @file v3/sem/ore_block_256/operators.sql ---! @brief Comparison operators on eql_v3.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. +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Equality backing function for ORE block types ---! @internal ---! ---! @param a eql_v3.ore_block_256 Left operand ---! @param b eql_v3.ore_block_256 Right operand ---! @return boolean True if the ORE blocks are equal ---! ---! @see eql_v3.compare_ore_block_256_terms -CREATE FUNCTION eql_v3.ore_block_256_eq(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_block_256_terms(a, b) = 0 -$$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Not-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3.ore_block_256 Left operand ---! @param b eql_v3.ore_block_256 Right operand ---! @return boolean True if the ORE blocks are not equal ---! ---! @see eql_v3.compare_ore_block_256_terms -CREATE FUNCTION eql_v3.ore_block_256_neq(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_block_256_terms(a, b) <> 0 -$$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Less-than backing function for ORE block types ---! @internal ---! ---! @param a eql_v3.ore_block_256 Left operand ---! @param b eql_v3.ore_block_256 Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3.compare_ore_block_256_terms -CREATE FUNCTION eql_v3.ore_block_256_lt(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_block_256_terms(a, b) = -1 -$$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Less-than-or-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3.ore_block_256 Left operand ---! @param b eql_v3.ore_block_256 Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3.compare_ore_block_256_terms -CREATE FUNCTION eql_v3.ore_block_256_lte(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_block_256_terms(a, b) != 1 -$$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); ---! @brief Greater-than backing function for ORE block types ---! @internal ---! ---! @param a eql_v3.ore_block_256 Left operand ---! @param b eql_v3.ore_block_256 Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3.compare_ore_block_256_terms -CREATE FUNCTION eql_v3.ore_block_256_gt(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_block_256_terms(a, b) = 1 -$$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord, RIGHTARG = jsonb +); ---! @brief Greater-than-or-equal backing function for ORE block types ---! @internal ---! ---! @param a eql_v3.ore_block_256 Left operand ---! @param b eql_v3.ore_block_256 Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3.compare_ore_block_256_terms -CREATE FUNCTION eql_v3.ore_block_256_gte(a eql_v3.ore_block_256, b eql_v3.ore_block_256) -RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_block_256_terms(a, b) != -1 -$$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord +); +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); ---! @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._ord_ore equality wrappers). -CREATE OPERATOR = ( - FUNCTION=eql_v3.ore_block_256_eq, - LEFTARG=eql_v3.ore_block_256, - RIGHTARG=eql_v3.ore_block_256, - COMMUTATOR = =, - NEGATOR = <>, - RESTRICT = eqsel, - JOIN = eqjoinsel, - HASHES, - MERGES +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord, RIGHTARG = jsonb ); ---! @brief <> operator for ORE block types -CREATE OPERATOR <> ( - FUNCTION=eql_v3.ore_block_256_neq, - LEFTARG=eql_v3.ore_block_256, - RIGHTARG=eql_v3.ore_block_256, - COMMUTATOR = <>, - NEGATOR = =, - RESTRICT = neqsel, - JOIN = neqjoinsel, - MERGES +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord ); ---! @brief > operator for ORE block types -CREATE OPERATOR > ( - FUNCTION=eql_v3.ore_block_256_gt, - LEFTARG=eql_v3.ore_block_256, - RIGHTARG=eql_v3.ore_block_256, - COMMUTATOR = <, - NEGATOR = <=, - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord, RIGHTARG = text ); ---! @brief < operator for ORE block types -CREATE OPERATOR < ( - FUNCTION=eql_v3.ore_block_256_lt, - LEFTARG=eql_v3.ore_block_256, - RIGHTARG=eql_v3.ore_block_256, - COMMUTATOR = >, - NEGATOR = >=, - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord, RIGHTARG = integer ); ---! @brief <= operator for ORE block types -CREATE OPERATOR <= ( - FUNCTION=eql_v3.ore_block_256_lte, - LEFTARG=eql_v3.ore_block_256, - RIGHTARG=eql_v3.ore_block_256, - COMMUTATOR = >=, - NEGATOR = >, - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord ); ---! @brief >= operator for ORE block types -CREATE OPERATOR >= ( - FUNCTION=eql_v3.ore_block_256_gte, - LEFTARG=eql_v3.ore_block_256, - RIGHTARG=eql_v3.ore_block_256, - COMMUTATOR = <=, - NEGATOR = <, - RESTRICT = scalargesel, - JOIN = scalargejoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord, RIGHTARG = text ); ---! @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.) +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord, RIGHTARG = integer +); ---! @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.eq_term(col)` ---! (which calls this) engage structurally. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3.hmac_256(val jsonb) - RETURNS eql_v3.hmac_256 - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm')::eql_v3.hmac_256 -$$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord, RIGHTARG = text +); ---! @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.has_hmac_256(val jsonb) - RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm') IS NOT NULL -$$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord, RIGHTARG = text[] +); ---! @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.) +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord, RIGHTARG = text[] +); ---! @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.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; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord, RIGHTARG = jsonpath +); ---! @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.match_term(col)` (which ---! calls this) engages structurally. Mirrors `eql_v3.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.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.bloom_filter(val jsonb) - RETURNS eql_v3.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.bloom_filter - END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord, RIGHTARG = jsonpath +); ---! @file v3/scalars/timestamp/timestamp_types.sql ---! @brief Encrypted-domain types for timestamp. +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord, RIGHTARG = text[] +); -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' = '2' - ); - END IF; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord, RIGHTARG = text[] +); - --! @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' = '2' - ); - END IF; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = integer +); - --! @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' = '2' - ); - END IF; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = text[] +); - --! @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' = '2' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord, RIGHTARG = text[] +); ---! @file v3/scalars/int4/int4_types.sql ---! @brief Encrypted-domain types for int4. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.int4. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int4' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int4 AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '2' - ); - END IF; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord, RIGHTARG = jsonb +); - --! @brief Encrypted domain eql_v3.int4_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int4_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int4_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '2' - ); - END IF; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); +-- AUTOMATICALLY GENERATED FILE. - --! @brief Encrypted domain eql_v3.int4_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int4_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int4_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' = '2' - ); +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for public.date_ord. + +--! @brief State function for min on public.date_ord. +--! @param state public.date_ord +--! @param value public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord, value public.date_ord) +RETURNS public.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 Encrypted domain eql_v3.int4_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int4_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int4_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' = '2' - ); +--! @brief min aggregate for public.date_ord. +--! @param input public.date_ord +--! @return public.date_ord +CREATE AGGREGATE eql_v3.min(public.date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord. +--! @param state public.date_ord +--! @param value public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord, value public.date_ord) +RETURNS public.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; -END + RETURN state; +END; $$; + +--! @brief max aggregate for public.date_ord. +--! @param input public.date_ord +--! @return public.date_ord +CREATE AGGREGATE eql_v3.max(public.date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_ord_functions.sql ---! @brief Functions for eql_v3.int4_ord. +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for public.date_ord_ore. ---! @brief Index extractor for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.int4_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.int4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. +--! @brief Operator wrapper for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.int4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. +--! @brief Operator wrapper for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.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.int4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. +--! @brief Operator wrapper for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.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.int4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. +--! @brief Operator wrapper for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.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.int4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. +--! @brief Operator wrapper for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.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.int4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.date_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord. +--! @brief Operator wrapper for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @brief Unsupported operator blocker for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ore, b public.date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @brief Unsupported operator blocker for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param selector text ---! @return eql_v3.int4_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.int4_ord, selector text) -RETURNS eql_v3.int4_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_ord'; END; $$ +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ore, selector text) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param selector integer ---! @return eql_v3.int4_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.int4_ord, selector integer) -RETURNS eql_v3.int4_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_ord'; END; $$ +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ore, selector integer) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @brief Unsupported operator blocker for public.date_ord_ore. --! @param a jsonb ---! @param selector eql_v3.int4_ord ---! @return eql_v3.int4_ord -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int4_ord) -RETURNS eql_v3.int4_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_ord'; END; $$ +--! @param selector public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord_ore) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @brief Unsupported operator blocker for public.date_ord_ore. --! @param a jsonb ---! @param selector eql_v3.int4_ord +--! @param selector public.date_ord_ore --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int4_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int4_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int4_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord ---! @param b eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ore, b public.date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. ---! @param a eql_v3.int4_ord +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @brief Unsupported operator blocker for public.date_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord +--! @param b public.date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int4_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_ord_operators.sql ---! @brief Operators for eql_v3.int4_ord. +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for public.date_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for public.date_ord_ore. + +--! @brief State function for min on public.date_ord_ore. +--! @param state public.date_ord_ore +--! @param value public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord_ore, value public.date_ord_ore) +RETURNS public.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 public.date_ord_ore. +--! @param input public.date_ord_ore +--! @return public.date_ord_ore +CREATE AGGREGATE eql_v3.min(public.date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord_ore. +--! @param state public.date_ord_ore +--! @param value public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord_ore, value public.date_ord_ore) +RETURNS public.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 public.date_ord_ore. +--! @param input public.date_ord_ore +--! @return public.date_ord_ore +CREATE AGGREGATE eql_v3.max(public.date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_eq_functions.sql ---! @brief Functions for eql_v3.int4_eq. +--! @file encrypted_domain/date/date_ord_ore_query_functions.sql +--! @brief Functions for public.date_ord_ore_query. ---! @brief Index extractor for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.int4_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4_eq, b eql_v3.int4_eq) +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore_query, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.int4_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4_eq) +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.int4_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4_eq, b eql_v3.int4_eq) +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore_query, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.int4_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4_eq) +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore_query, b public.date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.int4_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_query_operators.sql +--! @brief Operators for public.date_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_query_functions.sql +--! @brief Functions for public.date_ord_query. + +--! @brief Index extractor for public.date_ord_query. +--! @param a public.date_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_query_operators.sql +--! @brief Operators for public.date_ord_query. ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param selector text ---! @return eql_v3.int4_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.int4_eq, selector text) -RETURNS eql_v3.int4_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param selector integer ---! @return eql_v3.int4_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.int4_eq, selector integer) -RETURNS eql_v3.int4_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param selector eql_v3.int4_eq ---! @return eql_v3.int4_eq -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int4_eq) -RETURNS eql_v3.int4_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param selector eql_v3.int4_eq ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int4_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int4_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int4_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int4_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int4_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int4_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int4_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int4_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +--! @file v3/scalars/double/double_query_types.sql +--! @brief Query-operand domains for double (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.double_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; +DO $$ +BEGIN + --! @brief Query-operand domain public.double_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN public.double_eq_query IS 'EQL double query operand (equality)'; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain public.double_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int4_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN public.double_ord_ore_query IS 'EQL double query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b eql_v3.int4_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4_eq, b eql_v3.int4_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain public.double_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a eql_v3.int4_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN public.double_ord_query IS 'EQL double query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.int4_eq. ---! @param a jsonb ---! @param b eql_v3.int4_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int4_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_eq'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain public.double_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ope_query IS 'EQL double query operand (equality, ordering)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/int2/int2_types.sql ---! @brief Encrypted-domain types for int2. +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. DO $$ BEGIN - --! @brief Encrypted domain eql_v3.int2. + --! @brief Encrypted domain public.double. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'int2' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'double' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.int2 AS jsonb + CREATE DOMAIN public.double AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '2' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.int2_eq. + COMMENT ON DOMAIN public.double IS 'EQL encrypted double (storage only)'; + + --! @brief Encrypted domain public.double_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'int2_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'double_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.int2_eq AS jsonb + CREATE DOMAIN public.double_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '2' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.int2_ord_ore. + COMMENT ON DOMAIN public.double_eq IS 'EQL encrypted double (equality)'; + + --! @brief Encrypted domain public.double_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'int2_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'double_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.int2_ord_ore AS jsonb + CREATE DOMAIN public.double_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1999,16 +12594,18 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '2' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.int2_ord. + COMMENT ON DOMAIN public.double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.double_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'int2_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'double_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.int2_ord AS jsonb + CREATE DOMAIN public.double_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -2017,14337 +12614,14809 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '2' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.double_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.double_ord_ope IS 'EQL encrypted double (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_ord_ore_functions.sql ---! @brief Functions for eql_v3.int2_ord_ore. +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for public.double_eq. ---! @brief Index extractor for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.int2_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.double_eq. +--! @param a public.double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.double_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.double_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.int2_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.double_eq) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @brief Operator wrapper for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.double_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.double_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.int2_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.double_eq) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @brief Operator wrapper for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.double_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2_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.int2_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord_ore) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2_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.int2_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord_ore) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2_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.int2_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord_ore) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2_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.int2_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int2_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord_ore) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.double_eq, b public.double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_eq, b public.double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param selector text ---! @return eql_v3.int2_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.int2_ord_ore, selector text) -RETURNS eql_v3.int2_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_ord_ore'; END; $$ +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.double_eq, selector text) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param selector integer ---! @return eql_v3.int2_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.int2_ord_ore, selector integer) -RETURNS eql_v3.int2_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_ord_ore'; END; $$ +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.double_eq, selector integer) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param selector eql_v3.int2_ord_ore ---! @return eql_v3.int2_ord_ore -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int2_ord_ore) -RETURNS eql_v3.int2_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_ord_ore'; END; $$ +--! @param selector public.double_eq +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_eq) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.double_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.double_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param selector eql_v3.int2_ord_ore +--! @param selector public.double_eq --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int2_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.double_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int2_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int2_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int2_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int2_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int2_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int2_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore ---! @param b eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.double_eq, b public.double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. ---! @param a eql_v3.int2_ord_ore +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.double_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @brief Unsupported operator blocker for public.double_eq. --! @param a jsonb ---! @param b eql_v3.int2_ord_ore +--! @param b public.double_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_ord_functions.sql ---! @brief Functions for eql_v3.int2_ord. +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for public.double_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_query_functions.sql +--! @brief Functions for public.double_eq_query. ---! @brief Index extractor for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.int2_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.double_eq_query. +--! @param a public.double_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.double_eq_query) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq +--! @param b public.double_eq_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2_ord, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.double_eq_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b jsonb +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq_query +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.double_eq_query, b public.double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.int2_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a jsonb ---! @param b eql_v3.int2_ord +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq +--! @param b public.double_eq_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.double_eq_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq_query +--! @param b public.double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2_ord, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3.neq(a public.double_eq_query, b public.double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_query_operators.sql +--! @brief Operators for public.double_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for public.double. + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2_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.int2_ord) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2_ord, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2_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.int2_ord) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2_ord, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2_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.int2_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2_ord, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2_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.int2_ord) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2_ord, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2_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.int2_ord) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int2_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int2_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.double, b public.double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double, b public.double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param selector text ---! @return eql_v3.int2_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.int2_ord, selector text) -RETURNS eql_v3.int2_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_ord'; END; $$ +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a public.double, selector text) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param selector integer ---! @return eql_v3.int2_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.int2_ord, selector integer) -RETURNS eql_v3.int2_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_ord'; END; $$ +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a public.double, selector integer) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param selector eql_v3.int2_ord ---! @return eql_v3.int2_ord -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int2_ord) -RETURNS eql_v3.int2_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_ord'; END; $$ +--! @param selector public.double +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param selector eql_v3.int2_ord +--! @param selector public.double --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int2_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int2_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int2_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int2_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int2_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int2_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int2_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord ---! @param b eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.double, b public.double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. ---! @param a eql_v3.int2_ord +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @brief Unsupported operator blocker for public.double. --! @param a jsonb ---! @param b eql_v3.int2_ord +--! @param b public.double --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_ord_operators.sql ---! @brief Operators for eql_v3.int2_ord. +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for public.double. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double, RIGHTARG = public.double ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_functions.sql ---! @brief Functions for eql_v3.int2. +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for public.double_ord. + +--! @brief Index extractor for public.double_ord. +--! @param a public.double_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord, b public.double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord, b public.double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector text +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord, selector text) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector integer +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord, selector integer) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param selector public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param selector public.double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b jsonb +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a jsonb ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b jsonb +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord, b public.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for public.double_ord_ope. + +--! @brief Index extractor for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int2) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2, b eql_v3.int2) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.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::public.double_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Operator wrapper for public.double_ord_ope. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int2) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2, b eql_v3.int2) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.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::public.double_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Operator wrapper for public.double_ord_ope. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int2) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int2'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ope, b public.double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord_ope. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ope, b public.double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord_ope. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param selector text ---! @return eql_v3.int2 -CREATE FUNCTION eql_v3."->"(a eql_v3.int2, selector text) -RETURNS eql_v3.int2 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2'; END; $$ +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ope, selector text) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param selector integer ---! @return eql_v3.int2 -CREATE FUNCTION eql_v3."->"(a eql_v3.int2, selector integer) -RETURNS eql_v3.int2 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2'; END; $$ +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ope, selector integer) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord_ope. --! @param a jsonb ---! @param selector eql_v3.int2 ---! @return eql_v3.int2 -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int2) -RETURNS eql_v3.int2 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2'; END; $$ +--! @param selector public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord_ope) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord_ope. --! @param a jsonb ---! @param selector eql_v3.int2 +--! @param selector public.double_ord_ope --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int2, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int2, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int2, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int2, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int2, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int2, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int2, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 ---! @param b eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ope, b public.double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. ---! @param a eql_v3.int2 +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2. +--! @brief Unsupported operator blocker for public.double_ord_ope. --! @param a jsonb ---! @param b eql_v3.int2 +--! @param b public.double_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_ord_ore_operators.sql ---! @brief Operators for eql_v3.int2_ord_ore. +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for public.double_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/float8/float8_types.sql ---! @brief Encrypted-domain types for float8. +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for public.double_ord_ope. -DO $$ +--! @brief State function for min on public.double_ord_ope. +--! @param state public.double_ord_ope +--! @param value public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord_ope, value public.double_ord_ope) +RETURNS public.double_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ BEGIN - --! @brief Encrypted domain eql_v3.float8. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float8' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float8 AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '2' - ); - END IF; - - --! @brief Encrypted domain eql_v3.float8_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float8_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float8_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '2' - ); + IF value < state THEN + RETURN value; END IF; + RETURN state; +END; +$$; - --! @brief Encrypted domain eql_v3.float8_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float8_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float8_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' = '2' - ); - END IF; +--! @brief min aggregate for public.double_ord_ope. +--! @param input public.double_ord_ope +--! @return public.double_ord_ope +CREATE AGGREGATE eql_v3.min(public.double_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); - --! @brief Encrypted domain eql_v3.float8_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float8_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float8_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' = '2' - ); +--! @brief State function for max on public.double_ord_ope. +--! @param state public.double_ord_ope +--! @param value public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord_ope, value public.double_ord_ope) +RETURNS public.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; -END + RETURN state; +END; $$; + +--! @brief max aggregate for public.double_ord_ope. +--! @param input public.double_ord_ope +--! @return public.double_ord_ope +CREATE AGGREGATE eql_v3.max(public.double_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_ord_ore_functions.sql ---! @brief Functions for eql_v3.float8_ord_ore. +--! @file encrypted_domain/double/double_ord_ope_query_functions.sql +--! @brief Functions for public.double_ord_ope_query. ---! @brief Index extractor for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.float8_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8_ord_ore, b eql_v3.float8_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.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8_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.float8_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float8_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord_ore) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8_ord_ore, b eql_v3.float8_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.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8_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.float8_ord_ore) $$; - ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float8_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope_query, b public.double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.float8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope_query, b public.double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.float8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope_query, b public.double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope_query, b public.double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.float8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope_query, b public.double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.float8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float8_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope_query, b public.double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float8_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float8_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param selector text ---! @return eql_v3.float8_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.float8_ord_ore, selector text) -RETURNS eql_v3.float8_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param selector integer ---! @return eql_v3.float8_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.float8_ord_ore, selector integer) -RETURNS eql_v3.float8_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.float8_ord_ore ---! @return eql_v3.float8_ord_ore -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float8_ord_ore) -RETURNS eql_v3.float8_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.float8_ord_ore ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float8_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float8_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float8_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/double/double_ord_ope_query_operators.sql +--! @brief Operators for public.double_ord_ope_query. ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float8_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float8_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float8_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float8_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float8_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float8_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b eql_v3.float8_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8_ord_ore, b eql_v3.float8_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a eql_v3.float8_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float8_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float8_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_ord_ore_operators.sql ---! @brief Operators for eql_v3.float8_ord_ore. +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for public.double_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.double_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord, RIGHTARG = public.double_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for public.double_ord. + +--! @brief State function for min on public.double_ord. +--! @param state public.double_ord +--! @param value public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord, value public.double_ord) +RETURNS public.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 public.double_ord. +--! @param input public.double_ord +--! @return public.double_ord +CREATE AGGREGATE eql_v3.min(public.double_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord. +--! @param state public.double_ord +--! @param value public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord, value public.double_ord) +RETURNS public.double_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord. +--! @param input public.double_ord +--! @return public.double_ord +CREATE AGGREGATE eql_v3.max(public.double_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_ord_functions.sql ---! @brief Functions for eql_v3.float8_ord. +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for public.double_ord_ore. ---! @brief Index extractor for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.float8_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.float8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. +--! @brief Operator wrapper for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.float8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. +--! @brief Operator wrapper for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.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.float8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. +--! @brief Operator wrapper for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.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.float8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. +--! @brief Operator wrapper for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.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.float8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. +--! @brief Operator wrapper for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.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.float8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.double_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float8_ord. +--! @brief Operator wrapper for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @brief Unsupported operator blocker for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ore, b public.double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @brief Unsupported operator blocker for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param selector text ---! @return eql_v3.float8_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.float8_ord, selector text) -RETURNS eql_v3.float8_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_ord'; END; $$ +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ore, selector text) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param selector integer ---! @return eql_v3.float8_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.float8_ord, selector integer) -RETURNS eql_v3.float8_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_ord'; END; $$ +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ore, selector integer) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @brief Unsupported operator blocker for public.double_ord_ore. --! @param a jsonb ---! @param selector eql_v3.float8_ord ---! @return eql_v3.float8_ord -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float8_ord) -RETURNS eql_v3.float8_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_ord'; END; $$ +--! @param selector public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord_ore) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @brief Unsupported operator blocker for public.double_ord_ore. --! @param a jsonb ---! @param selector eql_v3.float8_ord +--! @param selector public.double_ord_ore --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float8_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float8_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float8_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float8_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float8_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float8_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float8_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float8_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord ---! @param b eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8_ord, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ore, b public.double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. ---! @param a eql_v3.float8_ord +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @brief Unsupported operator blocker for public.double_ord_ore. --! @param a jsonb ---! @param b eql_v3.float8_ord +--! @param b public.double_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float8_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_functions.sql ---! @brief Functions for eql_v3.float8. +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for public.double_ord_ore. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for public.double_ord_ore. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.double_ord_ore. +--! @param state public.double_ord_ore +--! @param value public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord_ore, value public.double_ord_ore) +RETURNS public.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 Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.double_ord_ore. +--! @param input public.double_ord_ore +--! @return public.double_ord_ore +CREATE AGGREGATE eql_v3.min(public.double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.double_ord_ore. +--! @param state public.double_ord_ore +--! @param value public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord_ore, value public.double_ord_ore) +RETURNS public.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 Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.double_ord_ore. +--! @param input public.double_ord_ore +--! @return public.double_ord_ore +CREATE AGGREGATE eql_v3.max(public.double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/double/double_ord_ore_query_functions.sql +--! @brief Functions for public.double_ord_ore_query. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param selector text ---! @return eql_v3.float8 -CREATE FUNCTION eql_v3."->"(a eql_v3.float8, selector text) -RETURNS eql_v3.float8 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param selector integer ---! @return eql_v3.float8 -CREATE FUNCTION eql_v3."->"(a eql_v3.float8, selector integer) -RETURNS eql_v3.float8 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param selector eql_v3.float8 ---! @return eql_v3.float8 -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float8) -RETURNS eql_v3.float8 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param selector eql_v3.float8 ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float8) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float8, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text[] +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float8, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text[] +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float8, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonpath +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float8, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonpath +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float8, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float8, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float8, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/double/double_ord_ore_query_operators.sql +--! @brief Operators for public.double_ord_ore_query. ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float8, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b eql_v3.float8 ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8, b eql_v3.float8) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a eql_v3.float8 ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float8. ---! @param a jsonb ---! @param b eql_v3.float8 ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float8) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @file v3/scalars/date/date_types.sql ---! @brief Encrypted-domain types for date. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); -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' = '2' - ); - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - --! @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' = '2' - ); - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - --! @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' = '2' - ); - END IF; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - --! @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' = '2' - ); - END IF; -END -$$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for eql_v3.date_ord_ore. +--! @file encrypted_domain/double/double_ord_query_functions.sql +--! @brief Functions for public.double_ord_query. ---! @brief Index extractor for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.double_ord_query. +--! @param a public.double_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_query) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +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 +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.double_ord_query, b public.double_ord) 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) $$; +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 eql_v3.date_ord_ore +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.double_ord_query, b public.double_ord) 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) $$; +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 eql_v3.date_ord_ore +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.double_ord_query, b public.double_ord) 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) $$; +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 eql_v3.date_ord_ore +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.double_ord_query, b public.double_ord) 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) $$; +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 eql_v3.date_ord_ore +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.double_ord_query, b public.double_ord) 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) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord_ore. ---! @param a jsonb ---! @param b eql_v3.date_ord_ore +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord_query) 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) $$; +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 eql_v3.date_ord_ore +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.double_ord_query, b public.double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @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) $$; +--! @file encrypted_domain/double/double_ord_query_operators.sql +--! @brief Operators for public.double_ord_query. ---! @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) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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.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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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.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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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.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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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.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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @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."->"(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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @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."->"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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."->"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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."->>"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @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."->>"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @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."->>"(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; +--! @file v3/scalars/integer/integer_query_types.sql +--! @brief Query-operand domains for integer (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.integer_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. ---! @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."?"(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; +DO $$ +BEGIN + --! @brief Query-operand domain public.integer_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(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; + COMMENT ON DOMAIN public.integer_eq_query IS 'EQL integer query operand (equality)'; ---! @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."?&"(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 Query-operand domain public.integer_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(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; + COMMENT ON DOMAIN public.integer_ord_ore_query IS 'EQL integer query operand (equality, ordering)'; ---! @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."@@"(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 Query-operand domain public.integer_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.date_ord_ore. ---! @param a eql_v3.date_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(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; + COMMENT ON DOMAIN public.integer_ord_query IS 'EQL integer query operand (equality, ordering)'; ---! @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."#>>"(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 Query-operand domain public.integer_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ope_query IS 'EQL integer query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_types.sql +--! @brief Encrypted-domain types for integer. + +DO $$ +BEGIN + --! @brief Encrypted domain public.integer. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer IS 'EQL encrypted integer (storage only)'; + + --! @brief Encrypted domain public.integer_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 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."-"(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; + COMMENT ON DOMAIN public.integer_eq IS 'EQL encrypted integer (equality)'; ---! @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."-"(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 Encrypted domain public.integer_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 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."-"(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; + COMMENT ON DOMAIN public.integer_ord_ore IS 'EQL encrypted integer (equality, ordering)'; ---! @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."#-"(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 Encrypted domain public.integer_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 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."||"(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; + COMMENT ON DOMAIN public.integer_ord IS 'EQL encrypted integer (equality, ordering)'; ---! @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."||"(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 Encrypted domain public.integer_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; ---! @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."||"(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; + COMMENT ON DOMAIN public.integer_ord_ope IS 'EQL encrypted integer (equality, ordering)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for eql_v3.date_eq. +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for public.integer_eq. ---! @brief Index extractor for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.date_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.integer_eq. +--! @param a public.integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.integer_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +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 +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.date_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.integer_eq) $$; ---! @brief Operator wrapper for eql_v3.date_eq. +--! @brief Operator wrapper for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_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) $$; +AS $$ SELECT eql_v3.eq_term(a::public.integer_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 +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.date_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.integer_eq) $$; ---! @brief Operator wrapper for eql_v3.date_eq. +--! @brief Operator wrapper for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_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) $$; +AS $$ SELECT eql_v3.eq_term(a::public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.integer_eq, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.integer_eq, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.integer_eq, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.integer_eq, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.integer_eq, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_eq, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param b eql_v3.date_eq +--! @param b public.integer_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param selector text ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.integer_eq, selector text) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param selector integer ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.integer_eq, selector integer) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param selector eql_v3.date_eq ---! @return eql_v3.date_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.integer_eq +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_eq) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.date_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.date_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @brief Unsupported operator blocker for public.integer_eq. --! @param a jsonb ---! @param selector eql_v3.date_eq +--! @param selector public.integer_eq --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.date_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.integer_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.date_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.date_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.date_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.date_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_eq, b public.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_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 +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.date_eq, b eql_v3.date_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for public.integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_query_functions.sql +--! @brief Functions for public.integer_eq_query. + +--! @brief Index extractor for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.integer_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq +--! @param b public.integer_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq_query, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq +--! @param b public.integer_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq_query, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_query_operators.sql +--! @brief Operators for public.integer_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a eql_v3.date_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_eq. ---! @param a jsonb ---! @param b eql_v3.date_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for eql_v3.date. +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for public.integer. ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.eq(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.neq(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lt(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lte(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gt(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gte(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contains(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param selector text ---! @return eql_v3.date -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a public.integer, selector text) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param selector integer ---! @return eql_v3.date -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a public.integer, selector integer) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param selector eql_v3.date ---! @return eql_v3.date -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.integer +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.date, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.date, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param selector eql_v3.date +--! @param selector public.integer --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.date) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.date, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.date, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.date, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.date, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.date, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.date, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date ---! @param b eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.date, b eql_v3.date) +CREATE FUNCTION eql_v3_internal."||"(a public.integer, b public.integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. ---! @param a eql_v3.date +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.date, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.date. +--! @brief Unsupported operator blocker for public.integer. --! @param a jsonb ---! @param b eql_v3.date +--! @param b public.integer --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.date) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for eql_v3.date_ord_ore. +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for public.integer. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer, RIGHTARG = public.integer ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer ); -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/numeric/numeric_types.sql ---! @brief Encrypted-domain types for numeric. +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for public.integer_ord. -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' = '2' - ); - END IF; +--! @brief Index extractor for public.integer_ord. +--! @param a public.integer_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.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 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' = '2' - ); - END IF; +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector text +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord, selector text) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector integer +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord, selector integer) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param selector public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param selector public.integer_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; - --! @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' = '2' - ); - END IF; +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; - --! @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' = '2' - ); - END IF; -END -$$; +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord, b public.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.numeric_ord_ore. +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for public.integer_ord_ope. ---! @brief Index extractor for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(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 +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord_ope) 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) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) = eql_v3.ord_ope_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 +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord_ope) 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) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) <> eql_v3.ord_ope_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 +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord_ope) 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) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) < eql_v3.ord_ope_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 +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord_ope) 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) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) <= eql_v3.ord_ope_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 +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord_ope) 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) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) > eql_v3.ord_ope_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 +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @brief Operator wrapper for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord_ope) 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) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) >= eql_v3.ord_ope_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 +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; 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 +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param selector text ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ope, selector text) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param selector integer ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ope, selector integer) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.integer_ord_ope. --! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore ---! @return eql_v3.numeric_ord_ore -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord_ope) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.integer_ord_ope. --! @param a jsonb ---! @param selector eql_v3.numeric_ord_ore +--! @param selector public.integer_ord_ope --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord_ope'; 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 +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ope, b public.integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. ---! @param a eql_v3.numeric_ord_ore +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @brief Unsupported operator blocker for public.integer_ord_ope. --! @param a jsonb ---! @param b eql_v3.numeric_ord_ore +--! @param b public.integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_eq_functions.sql ---! @brief Functions for eql_v3.numeric_eq. +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for public.integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for public.integer_ord_ope. + +--! @brief State function for min on public.integer_ord_ope. +--! @param state public.integer_ord_ope +--! @param value public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord_ope, value public.integer_ord_ope) +RETURNS public.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 public.integer_ord_ope. +--! @param input public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE AGGREGATE eql_v3.min(public.integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord_ope. +--! @param state public.integer_ord_ope +--! @param value public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord_ope, value public.integer_ord_ope) +RETURNS public.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 public.integer_ord_ope. +--! @param input public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE AGGREGATE eql_v3.max(public.integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_query_functions.sql +--! @brief Functions for public.integer_ord_ope_query. ---! @brief Index extractor for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.numeric_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope_query, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope_query, b public.integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope_query, b public.integer_ord_ope) 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.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.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.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.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.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.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.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.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.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.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.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.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.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; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.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."->"(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."->"(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."->"(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."->>"(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."->>"(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."->>"(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; +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3."?"(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; +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(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; +--! @file encrypted_domain/integer/integer_ord_ope_query_operators.sql +--! @brief Operators for public.integer_ord_ope_query. ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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."||"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a eql_v3.numeric_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.numeric_eq. ---! @param a jsonb ---! @param b eql_v3.numeric_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.numeric_ord_ore. +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for public.integer_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/bool/bool_types.sql ---! @brief Encrypted-domain types for bool. +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for public.integer_ord. -DO $$ +--! @brief State function for min on public.integer_ord. +--! @param state public.integer_ord +--! @param value public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord, value public.integer_ord) +RETURNS public.integer_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ BEGIN - --! @brief Encrypted domain eql_v3.bool. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'bool' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.bool AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '2' - ); + IF value < state THEN + RETURN value; END IF; -END + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord. +--! @param input public.integer_ord +--! @return public.integer_ord +CREATE AGGREGATE eql_v3.min(public.integer_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord. +--! @param state public.integer_ord +--! @param value public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord, value public.integer_ord) +RETURNS public.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 public.integer_ord. +--! @param input public.integer_ord +--! @return public.integer_ord +CREATE AGGREGATE eql_v3.max(public.integer_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bool/bool_functions.sql ---! @brief Functions for eql_v3.bool. +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for public.integer_ord_ore. ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Index extractor for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bool, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.bool, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.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::public.integer_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Operator wrapper for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bool, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.bool, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.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::public.integer_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Operator wrapper for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bool, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.bool, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.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::public.integer_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Operator wrapper for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bool, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.bool, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.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::public.integer_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Operator wrapper for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bool, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.bool, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.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::public.integer_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Operator wrapper for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bool, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.bool, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.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::public.integer_ord_ore) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Operator wrapper for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bool) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bool'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.bool, b eql_v3.bool) +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ore, b public.integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.bool, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Unsupported operator blocker for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.bool) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.bool, b eql_v3.bool) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ore, b public.integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.bool, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Unsupported operator blocker for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.bool) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param selector text ---! @return eql_v3.bool -CREATE FUNCTION eql_v3."->"(a eql_v3.bool, selector text) -RETURNS eql_v3.bool IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bool'; END; $$ +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ore, selector text) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param selector integer ---! @return eql_v3.bool -CREATE FUNCTION eql_v3."->"(a eql_v3.bool, selector integer) -RETURNS eql_v3.bool IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bool'; END; $$ +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ore, selector integer) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Unsupported operator blocker for public.integer_ord_ore. --! @param a jsonb ---! @param selector eql_v3.bool ---! @return eql_v3.bool -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.bool) -RETURNS eql_v3.bool IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bool'; END; $$ +--! @param selector public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord_ore) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.bool, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.bool, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Unsupported operator blocker for public.integer_ord_ore. --! @param a jsonb ---! @param selector eql_v3.bool +--! @param selector public.integer_ord_ore --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.bool) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.bool, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.bool, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.bool, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.bool, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.bool, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.bool, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.bool, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.bool, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.bool, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.bool, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.bool, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool ---! @param b eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.bool, b eql_v3.bool) +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ore, b public.integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. ---! @param a eql_v3.bool +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.bool, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.bool. +--! @brief Unsupported operator blocker for public.integer_ord_ore. --! @param a jsonb ---! @param b eql_v3.bool +--! @param b public.integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.bool) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bool'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/int8/int8_types.sql ---! @brief Encrypted-domain types for int8. +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for public.integer_ord_ore. -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.int8. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int8' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int8 AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '2' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Encrypted domain eql_v3.int8_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int8_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int8_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '2' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Encrypted domain eql_v3.int8_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int8_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int8_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' = '2' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Encrypted domain eql_v3.int8_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'int8_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.int8_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' = '2' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file encrypted_domain/int8/int8_functions.sql ---! @brief Functions for eql_v3.int8. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int8) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param selector text ---! @return eql_v3.int8 -CREATE FUNCTION eql_v3."->"(a eql_v3.int8, selector text) -RETURNS eql_v3.int8 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param selector integer ---! @return eql_v3.int8 -CREATE FUNCTION eql_v3."->"(a eql_v3.int8, selector integer) -RETURNS eql_v3.int8 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param selector eql_v3.int8 ---! @return eql_v3.int8 -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int8) -RETURNS eql_v3.int8 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param selector eql_v3.int8 ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int8) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int8, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int8, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int8, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int8, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int8, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int8, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int8, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for public.integer_ord_ore. ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int8, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.integer_ord_ore. +--! @param state public.integer_ord_ore +--! @param value public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord_ore, value public.integer_ord_ore) +RETURNS public.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 Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b eql_v3.int8 ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8, b eql_v3.int8) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.integer_ord_ore. +--! @param input public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE AGGREGATE eql_v3.min(public.integer_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.int8. ---! @param a eql_v3.int8 ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.integer_ord_ore. +--! @param state public.integer_ord_ore +--! @param value public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord_ore, value public.integer_ord_ore) +RETURNS public.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 Unsupported operator blocker for eql_v3.int8. ---! @param a jsonb ---! @param b eql_v3.int8 ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int8) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.integer_ord_ore. +--! @param input public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE AGGREGATE eql_v3.max(public.integer_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_ord_functions.sql ---! @brief Functions for eql_v3.int8_ord. +--! @file encrypted_domain/integer/integer_ord_ore_query_functions.sql +--! @brief Functions for public.integer_ord_ore_query. ---! @brief Index extractor for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.int8_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8_ord, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore_query, b public.integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.int8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8_ord, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore_query, b public.integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.int8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore_query, b public.integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8_ord, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore_query, b public.integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.int8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8_ord, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore_query, b public.integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.int8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore_query, b public.integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_query_operators.sql +--! @brief Operators for public.integer_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_query_functions.sql +--! @brief Functions for public.integer_ord_query. + +--! @brief Index extractor for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8_ord, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.integer_ord_query, b public.integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.int8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8_ord, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.neq(a public.integer_ord_query, b public.integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.int8_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int8_ord) +CREATE FUNCTION eql_v3.lt(a public.integer_ord_query, b public.integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8_ord, b eql_v3.int8_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int8_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_ord, b eql_v3.int8_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int8_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param selector text ---! @return eql_v3.int8_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.int8_ord, selector text) -RETURNS eql_v3.int8_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param selector integer ---! @return eql_v3.int8_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.int8_ord, selector integer) -RETURNS eql_v3.int8_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/integer/integer_ord_query_operators.sql +--! @brief Operators for public.integer_ord_query. ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a jsonb ---! @param selector eql_v3.int8_ord ---! @return eql_v3.int8_ord -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int8_ord) -RETURNS eql_v3.int8_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a jsonb ---! @param selector eql_v3.int8_ord ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int8_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int8_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int8_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int8_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int8_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int8_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int8_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int8_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +--! @file v3/scalars/numeric/numeric_query_types.sql +--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.numeric_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; +DO $$ +BEGIN + --! @brief Query-operand domain public.numeric_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int8_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN public.numeric_eq_query IS 'EQL numeric query operand (equality)'; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b eql_v3.int8_ord ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8_ord, b eql_v3.int8_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain public.numeric_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a eql_v3.int8_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN public.numeric_ord_ore_query IS 'EQL numeric query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.int8_ord. ---! @param a jsonb ---! @param b eql_v3.int8_ord ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int8_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. + --! @brief Query-operand domain public.numeric_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @file v3/scalars/text/text_types.sql ---! @brief Encrypted-domain types for text. + COMMENT ON DOMAIN public.numeric_ord_query IS 'EQL numeric query operand (equality, ordering)'; -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.text. + --! @brief Query-operand domain public.numeric_ord_ope_query (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'numeric_ord_ope_query' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text AS jsonb + CREATE DOMAIN public.numeric_ord_ope_query AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '2' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.text_eq. + COMMENT ON DOMAIN public.numeric_ord_ope_query IS 'EQL numeric query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain public.numeric. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'numeric' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_eq AS jsonb + CREATE DOMAIN public.numeric AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '2' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.text_match. + COMMENT ON DOMAIN public.numeric IS 'EQL encrypted numeric (storage only)'; + + --! @brief Encrypted domain public.numeric_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'numeric_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_match AS jsonb + CREATE DOMAIN public.numeric_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'bf' - AND VALUE->>'v' = '2' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.text_ord_ore. + COMMENT ON DOMAIN public.numeric_eq IS 'EQL encrypted numeric (equality)'; + + --! @brief Encrypted domain public.numeric_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_ord_ore AS jsonb + CREATE DOMAIN public.numeric_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' = '2' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.text_ord. + COMMENT ON DOMAIN public.numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.numeric_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'numeric_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_ord AS jsonb + CREATE DOMAIN public.numeric_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' = '2' + AND VALUE->>'v' = '3' ); END IF; - --! @brief Encrypted domain eql_v3.text_search. + COMMENT ON DOMAIN public.numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.numeric_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'numeric_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.text_search AS jsonb + CREATE DOMAIN public.numeric_ord_ope 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' = '2' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' ); END IF; + + COMMENT ON DOMAIN public.numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; END $$; -- 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.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord) -RETURNS eql_v3.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for public.numeric_eq. ---! @brief Index extractor for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.numeric_eq. +--! @param a public.numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.text_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.numeric_eq) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.numeric_eq) = 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 +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.text_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.numeric_eq) $$; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Operator wrapper for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.numeric_eq) <> 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 +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_eq, b public.numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_eq, b public.numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param selector text ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_eq, selector text) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param selector integer ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_eq, selector integer) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param selector eql_v3.text_ord ---! @return eql_v3.text_ord -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.numeric_eq +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_eq) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param selector eql_v3.text_ord +--! @param selector public.numeric_eq --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.text_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord ---! @param b eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_ord, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_eq, b public.numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. ---! @param a eql_v3.text_ord +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @brief Unsupported operator blocker for public.numeric_eq. --! @param a jsonb ---! @param b eql_v3.text_ord +--! @param b public.numeric_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for eql_v3.text_ord_ore. +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for public.numeric_eq. ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_ord_ore) -RETURNS eql_v3.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord_ore) -RETURNS eql_v3.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric_eq, RIGHTARG = 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.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) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric_eq, RIGHTARG = 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.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) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric_eq, RIGHTARG = 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.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) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric_eq, RIGHTARG = 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.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) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); ---! @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) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); ---! @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.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; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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.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; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); ---! @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.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; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); ---! @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.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; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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.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; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_eq, RIGHTARG = text +); ---! @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.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; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); ---! @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."->"(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; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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."->"(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; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_eq, RIGHTARG = text +); ---! @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."->"(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; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); ---! @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."->>"(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; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); ---! @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."->>"(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; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_eq, RIGHTARG = text +); ---! @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."->>"(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; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); ---! @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."?"(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; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); ---! @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."?|"(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; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_eq, RIGHTARG = jsonpath +); ---! @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."?&"(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; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_eq, RIGHTARG = jsonpath +); ---! @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."@?"(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; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); ---! @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."@@"(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; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); ---! @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."#>"(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; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = text +); ---! @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."#>>"(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; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_query_functions.sql +--! @brief Functions for public.numeric_eq_query. + +--! @brief Index extractor for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq +--! @param b public.numeric_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq_query, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief 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."-"(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 Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq +--! @param b public.numeric_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_ord_ore. ---! @param a eql_v3.text_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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 Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq_query, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @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."-"(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; +--! @file encrypted_domain/numeric/numeric_eq_query_operators.sql +--! @brief Operators for public.numeric_eq_query. ---! @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."#-"(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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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."||"(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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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."||"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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."||"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -- 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.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_match) -RETURNS eql_v3.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.bloom_filter(a::jsonb) $$; +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for public.numeric. ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.eq(a public.numeric, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.neq(a public.numeric, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.lt(a public.numeric, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.lte(a public.numeric, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.gt(a public.numeric, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.gte(a public.numeric, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @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) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @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) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @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) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @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) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @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) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @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) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param selector text ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a public.numeric, selector text) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param selector integer ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a public.numeric, selector integer) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param selector eql_v3.text_match ---! @return eql_v3.text_match -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.numeric +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_match, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_match, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param selector eql_v3.text_match +--! @param selector public.numeric --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_match) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.text_match, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.numeric, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_match, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_match, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match ---! @param b eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_match, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric, b public.numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. ---! @param a eql_v3.text_match +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_match, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_match. +--! @brief Unsupported operator blocker for public.numeric. --! @param a jsonb ---! @param b eql_v3.text_match +--! @param b public.numeric --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_match) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for eql_v3.text_search. +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for public.numeric. ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_search) -RETURNS eql_v3.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) -RETURNS eql_v3.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric, RIGHTARG = jsonb +); ---! @brief Index extractor for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @return eql_v3.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.text_search) -RETURNS eql_v3.bloom_filter +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for public.numeric_ord. + +--! @brief Index extractor for public.numeric_ord. +--! @param a public.numeric_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.bloom_filter(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.numeric_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_search) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) = 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 +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.numeric_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_search) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) <> 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 +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.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.text_search) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) < 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 +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.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.text_search) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) <= 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 +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.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.text_search) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) > 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 +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.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.text_search) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.numeric_ord) $$; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Operator wrapper for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) >= 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 +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @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) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @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) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @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) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @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) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @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) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @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) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param selector text ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord, selector text) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param selector integer ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord, selector integer) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.numeric_ord. --! @param a jsonb ---! @param selector eql_v3.text_search ---! @return eql_v3.text_search -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_search, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_search, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.numeric_ord. --! @param a jsonb ---! @param selector eql_v3.text_search +--! @param selector public.numeric_ord --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_search) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.text_search, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.text_search, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.text_search, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_search, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_search, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.text_search, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search ---! @param b eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_search, b eql_v3.text_search) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord, b public.numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. ---! @param a eql_v3.text_search +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_search, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_search. +--! @brief Unsupported operator blocker for public.numeric_ord. --! @param a jsonb ---! @param b eql_v3.text_search +--! @param b public.numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_search) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for eql_v3.text_eq. +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for public.numeric_ord_ope. ---! @brief Index extractor for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.numeric_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_eq) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.text_eq. +--! @brief Operator wrapper for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.numeric_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_eq) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.text_eq. +--! @brief Operator wrapper for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a public.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::public.numeric_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a public.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::public.numeric_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a public.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::public.numeric_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gte(a public.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::public.numeric_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Operator wrapper for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ope, b public.numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ope, b public.numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param selector text ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ope, selector text) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param selector integer ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ope, selector integer) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.numeric_ord_ope. --! @param a jsonb ---! @param selector eql_v3.text_eq ---! @return eql_v3.text_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord_ope) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.text_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.numeric_ord_ope. --! @param a jsonb ---! @param selector eql_v3.text_eq +--! @param selector public.numeric_ord_ope --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.text_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq ---! @param b eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_eq, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ope, b public.numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. ---! @param a eql_v3.text_eq +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @brief Unsupported operator blocker for public.numeric_ord_ope. --! @param a jsonb ---! @param b eql_v3.text_eq +--! @param b public.numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ LANGUAGE plpgsql; -- 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.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for eql_v3.text_ord. +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for public.numeric_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.text_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.text_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/float4/float4_types.sql ---! @brief Encrypted-domain types for float4. - -DO $$ -BEGIN - --! @brief Encrypted domain eql_v3.float4. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float4' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float4 AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '2' - ); - END IF; - - --! @brief Encrypted domain eql_v3.float4_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float4_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float4_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '2' - ); - END IF; - - --! @brief Encrypted domain eql_v3.float4_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float4_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float4_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' = '2' - ); - END IF; + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); - --! @brief Encrypted domain eql_v3.float4_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'float4_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.float4_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' = '2' - ); - END IF; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); ---! @file encrypted_domain/float4/float4_ord_ore_functions.sql ---! @brief Functions for eql_v3.float4_ord_ore. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); ---! @brief Index extractor for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.float4_ord_ore) -RETURNS eql_v3.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql +--! @brief Aggregates for public.numeric_ord_ope. ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4_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.float4_ord_ore) $$; +--! @brief State function for min on public.numeric_ord_ope. +--! @param state public.numeric_ord_ope +--! @param value public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord_ope, value public.numeric_ord_ope) +RETURNS public.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 Operator wrapper for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float4_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord_ore) = eql_v3.ord_term(b) $$; +--! @brief min aggregate for public.numeric_ord_ope. +--! @param input public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE AGGREGATE eql_v3.min(public.numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief State function for max on public.numeric_ord_ope. +--! @param state public.numeric_ord_ope +--! @param value public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord_ope, value public.numeric_ord_ope) +RETURNS public.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 Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4_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.float4_ord_ore) $$; +--! @brief max aggregate for public.numeric_ord_ope. +--! @param input public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE AGGREGATE eql_v3.max(public.numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float4_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord_ore) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/numeric/numeric_ord_ope_query_functions.sql +--! @brief Functions for public.numeric_ord_ope_query. ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +--! @brief Index extractor for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope_query) +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.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.float4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope_query, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope_query, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.float4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope_query, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.float4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope_query, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope_query, b public.numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.float4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float4_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord_ore) >= eql_v3.ord_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float4_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float4_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param selector text ---! @return eql_v3.float4_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.float4_ord_ore, selector text) -RETURNS eql_v3.float4_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param selector integer ---! @return eql_v3.float4_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.float4_ord_ore, selector integer) -RETURNS eql_v3.float4_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.float4_ord_ore ---! @return eql_v3.float4_ord_ore -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float4_ord_ore) -RETURNS eql_v3.float4_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param selector eql_v3.float4_ord_ore ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float4_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_ope_query_operators.sql +--! @brief Operators for public.numeric_ord_ope_query. ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float4_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float4_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float4_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float4_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float4_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float4_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float4_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float4_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b eql_v3.float4_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4_ord_ore, b eql_v3.float4_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a eql_v3.float4_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for public.numeric_ord. ---! @brief Unsupported operator blocker for eql_v3.float4_ord_ore. ---! @param a jsonb ---! @param b eql_v3.float4_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float4_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @file encrypted_domain/float4/float4_eq_functions.sql ---! @brief Functions for eql_v3.float4_eq. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.float4_eq) -RETURNS eql_v3.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4_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.float4_eq) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float4_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.float4_eq) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4_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.float4_eq) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float4_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.float4_eq) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float4_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param selector text ---! @return eql_v3.float4_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.float4_eq, selector text) -RETURNS eql_v3.float4_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param selector integer ---! @return eql_v3.float4_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.float4_eq, selector integer) -RETURNS eql_v3.float4_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param selector eql_v3.float4_eq ---! @return eql_v3.float4_eq -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float4_eq) -RETURNS eql_v3.float4_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param selector eql_v3.float4_eq ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float4_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float4_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float4_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float4_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float4_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float4_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float4_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float4_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float4_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b eql_v3.float4_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4_eq, b eql_v3.float4_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for public.numeric_ord. + +--! @brief State function for min on public.numeric_ord. +--! @param state public.numeric_ord +--! @param value public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord, value public.numeric_ord) +RETURNS public.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 Unsupported operator blocker for eql_v3.float4_eq. ---! @param a eql_v3.float4_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.numeric_ord. +--! @param input public.numeric_ord +--! @return public.numeric_ord +CREATE AGGREGATE eql_v3.min(public.numeric_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.float4_eq. ---! @param a jsonb ---! @param b eql_v3.float4_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float4_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_eq'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.numeric_ord. +--! @param state public.numeric_ord +--! @param value public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord, value public.numeric_ord) +RETURNS public.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 public.numeric_ord. +--! @param input public.numeric_ord +--! @return public.numeric_ord +CREATE AGGREGATE eql_v3.max(public.numeric_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_ord_functions.sql ---! @brief Functions for eql_v3.float4_ord. +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for public.numeric_ord_ore. ---! @brief Index extractor for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.float4_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.float4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. +--! @brief Operator wrapper for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.float4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. +--! @brief Operator wrapper for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.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.float4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. +--! @brief Operator wrapper for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.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.float4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. +--! @brief Operator wrapper for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.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.float4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. +--! @brief Operator wrapper for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.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.float4_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.numeric_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.float4_ord. +--! @brief Operator wrapper for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @brief Unsupported operator blocker for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @brief Unsupported operator blocker for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param selector text ---! @return eql_v3.float4_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.float4_ord, selector text) -RETURNS eql_v3.float4_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_ord'; END; $$ +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ore, selector text) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param selector integer ---! @return eql_v3.float4_ord -CREATE FUNCTION eql_v3."->"(a eql_v3.float4_ord, selector integer) -RETURNS eql_v3.float4_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_ord'; END; $$ +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ore, selector integer) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @brief Unsupported operator blocker for public.numeric_ord_ore. --! @param a jsonb ---! @param selector eql_v3.float4_ord ---! @return eql_v3.float4_ord -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float4_ord) -RETURNS eql_v3.float4_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4_ord'; END; $$ +--! @param selector public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord_ore) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @brief Unsupported operator blocker for public.numeric_ord_ore. --! @param a jsonb ---! @param selector eql_v3.float4_ord +--! @param selector public.numeric_ord_ore --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float4_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float4_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float4_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float4_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord ---! @param b eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4_ord, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ore, b public.numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. ---! @param a eql_v3.float4_ord +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @brief Unsupported operator blocker for public.numeric_ord_ore. --! @param a jsonb ---! @param b eql_v3.float4_ord +--! @param b public.numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float4_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_ord_ore_operators.sql ---! @brief Operators for eql_v3.float4_ord_ore. +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for public.numeric_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_ord_operators.sql ---! @brief Operators for eql_v3.float4_ord. +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for public.numeric_ord_ore. + +--! @brief State function for min on public.numeric_ord_ore. +--! @param state public.numeric_ord_ore +--! @param value public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord_ore, value public.numeric_ord_ore) +RETURNS public.numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord_ore. +--! @param input public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE AGGREGATE eql_v3.min(public.numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +--! @brief State function for max on public.numeric_ord_ore. +--! @param state public.numeric_ord_ore +--! @param value public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord_ore, value public.numeric_ord_ore) +RETURNS public.numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord_ore. +--! @param input public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE AGGREGATE eql_v3.max(public.numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_query_functions.sql +--! @brief Functions for public.numeric_ord_ore_query. + +--! @brief Index extractor for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_query_operators.sql +--! @brief Operators for public.numeric_ord_ore_query. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float4_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.timestamp_ord_ore. +--! @file encrypted_domain/numeric/numeric_ord_query_functions.sql +--! @brief Functions for public.numeric_ord_query. ---! @brief Index extractor for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_query) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +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 +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_query, b public.numeric_ord) 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) $$; +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 eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_query, b public.numeric_ord) 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) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord_query) 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) $$; +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 eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_query, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonb +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord_query) 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) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_query, b public.numeric_ord) 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) $$; +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 eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_query, b public.numeric_ord) 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) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord_ore. ---! @param a jsonb ---! @param b eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord_query) 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) $$; +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 eql_v3.timestamp_ord_ore +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_query, b public.numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @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) $$; +--! @file encrypted_domain/numeric/numeric_ord_query_operators.sql +--! @brief Operators for public.numeric_ord_query. ---! @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) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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.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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @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.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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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.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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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.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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @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."->"(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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @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."->"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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."->"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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."->>"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @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."->>"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @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."->>"(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; +--! @file v3/scalars/real/real_query_types.sql +--! @brief Query-operand domains for real (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.real_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. ---! @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."?"(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; +DO $$ +BEGIN + --! @brief Query-operand domain public.real_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(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; + COMMENT ON DOMAIN public.real_eq_query IS 'EQL real query operand (equality)'; ---! @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."?&"(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 Query-operand domain public.real_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(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; + COMMENT ON DOMAIN public.real_ord_ore_query IS 'EQL real query operand (equality, ordering)'; ---! @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."@@"(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 Query-operand domain public.real_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(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; + COMMENT ON DOMAIN public.real_ord_query IS 'EQL real query operand (equality, ordering)'; ---! @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."#>>"(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 Query-operand domain public.real_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. ---! @param a eql_v3.timestamp_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; + COMMENT ON DOMAIN public.real_ord_ope_query IS 'EQL real query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. ---! @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."-"(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; +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. ---! @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."-"(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; +DO $$ +BEGIN + --! @brief Encrypted domain public.real. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; ---! @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."#-"(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; + COMMENT ON DOMAIN public.real IS 'EQL encrypted real (storage only)'; + + --! @brief Encrypted domain public.real_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.real_eq IS 'EQL encrypted real (equality)'; + + --! @brief Encrypted domain public.real_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.real_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 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."||"(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; + COMMENT ON DOMAIN public.real_ord IS 'EQL encrypted real (equality, ordering)'; ---! @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."||"(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 Encrypted domain public.real_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; ---! @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."||"(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; + COMMENT ON DOMAIN public.real_ord_ope IS 'EQL encrypted real (equality, ordering)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for eql_v3.timestamp_ord. +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for public.real_eq. ---! @brief Index extractor for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.real_eq. +--! @param a public.real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.real_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.real_eq, 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) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.real_eq) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.real_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.real_eq, 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) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.real_eq) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Operator wrapper for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.real_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @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) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.real_eq, b public.real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_eq, b public.real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param selector text ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.real_eq, selector text) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param selector integer ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.real_eq, selector integer) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord ---! @return eql_v3.timestamp_ord -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.real_eq +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_eq) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamp_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamp_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param selector eql_v3.timestamp_ord +--! @param selector public.real_eq --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord ---! @param b eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.real_eq, b public.real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. ---! @param a eql_v3.timestamp_ord +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @brief Unsupported operator blocker for public.real_eq. --! @param a jsonb ---! @param b eql_v3.timestamp_ord +--! @param b public.real_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for eql_v3.timestamp_ord. +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for public.real_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + LEFTARG = public.real_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + LEFTARG = jsonb, RIGHTARG = public.real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + LEFTARG = public.real_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + LEFTARG = jsonb, RIGHTARG = public.real_eq, 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 + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_eq, RIGHTARG = public.real_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for eql_v3.timestamp_eq. +--! @file encrypted_domain/real/real_eq_query_functions.sql +--! @brief Functions for public.real_eq_query. ---! @brief Index extractor for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.timestamp_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.real_eq_query. +--! @param a public.real_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.real_eq_query) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +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 +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq +--! @param b public.real_eq_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.real_eq_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b jsonb +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq_query +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.real_eq_query, b public.real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq +--! @param b public.real_eq_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.real_eq_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; +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 eql_v3.timestamp_eq +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq_query +--! @param b public.real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.real_eq_query, b public.real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_query_operators.sql +--! @brief Operators for public.real_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for public.real. ---! @brief Operator wrapper for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @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) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @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) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.real, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.real, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.real, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.real, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.real, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.real, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param selector text ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a public.real, selector text) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param selector integer ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a public.real, selector integer) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param selector eql_v3.timestamp_eq ---! @return eql_v3.timestamp_eq -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.real +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamp_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.real, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamp_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.real, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param selector eql_v3.timestamp_eq +--! @param selector public.real --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.real, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.real, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.real, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.real, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq ---! @param b eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.real, b public.real) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. ---! @param a eql_v3.timestamp_eq +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.real, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @brief Unsupported operator blocker for public.real. --! @param a jsonb ---! @param b eql_v3.timestamp_eq +--! @param b public.real --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.timestamp_ord_ore. +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for public.real. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real, RIGHTARG = public.real ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore -); - ---! @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.compare_ore_cllw_term -CREATE TYPE eql_v3.ore_cllw AS ( - bytes bytea + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real ); +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/sem/ore_cllw/functions.sql ---! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for public.real_ord. ---! @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.ore_cllw Composite carrying the CLLW ciphertext, or NULL ---! when the `oc` field is absent. ---! @see eql_v3.has_ore_cllw ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw(val jsonb) - RETURNS eql_v3.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.ore_cllw - END -$$; +--! @brief Index extractor for public.real_ord. +--! @param a public.real_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.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) $$; -COMMENT ON FUNCTION eql_v3.ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief 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.has_ore_cllw(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT val ->> 'oc' IS NOT NULL -$$; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.real_ord) $$; -COMMENT ON FUNCTION eql_v3.has_ore_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) = eql_v3.ord_term(b) $$; ---! @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.compare_ore_cllw_term -CREATE FUNCTION eql_v3.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 +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - len_a := LENGTH(a); - len_b := LENGTH(b); +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.real_ord) $$; - IF len_a != len_b THEN - RAISE EXCEPTION 'ore_cllw index terms are not the same length'; - END IF; +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) <> eql_v3.ord_term(b) $$; - 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; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - IF first_diff = 0 THEN - RETURN 0; - END IF; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.real_ord) $$; - 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 Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) < eql_v3.ord_term(b) $$; ---! @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.ore_cllw First term ---! @param b eql_v3.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.compare_ore_cllw_term_bytes -CREATE FUNCTION eql_v3.compare_ore_cllw_term(a eql_v3.ore_cllw, b eql_v3.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; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - IF a.bytes IS NULL OR b.bytes IS NULL THEN - RAISE EXCEPTION 'eql_v3.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3.ore_cllw(...) and not a hand-crafted ROW(NULL).'; - END IF; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.real_ord) $$; - len_a := LENGTH(a.bytes); - len_b := LENGTH(b.bytes); +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) <= eql_v3.ord_term(b) $$; - 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; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - IF len_a < len_b THEN - common_len := len_a; - ELSE - common_len := len_b; - END IF; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.real_ord) $$; - cmp_result := eql_v3.compare_ore_cllw_term_bytes( - SUBSTRING(a.bytes FROM 1 FOR common_len), - SUBSTRING(b.bytes FROM 1 FOR common_len) - ); +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) > eql_v3.ord_term(b) $$; - IF cmp_result = -1 THEN - RETURN -1; - ELSIF cmp_result = 1 THEN - RETURN 1; - END IF; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - IF len_a < len_b THEN - RETURN -1; - ELSIF len_a > len_b THEN - RETURN 1; - ELSE - RETURN 0; - END IF; -END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.real_ord) $$; ---! @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 Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) >= eql_v3.ord_term(b) $$; ---! @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.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 Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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 = 2`, `i`, an `sv` array, and valid sv entry elements. -CREATE FUNCTION eql_v3.is_valid_ste_vec_document_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND val ? 'v' - AND val ->> 'v' = '2' - 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.is_valid_ste_vec_entry_payload(elem) - ), - false - ) -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief Storage/root domain for an encrypted JSONB column. ---! ---! CHECK: a JSON object carrying the EQL envelope (`v = 2` 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":2,"sv":[...]}'::eql_v3.json`. -CREATE DOMAIN eql_v3.json AS jsonb - CHECK ( - eql_v3.is_valid_ste_vec_document_payload(VALUE) - ); +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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.is_valid_ste_vec_entry_payload(VALUE) - ); +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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":"","hm":""}]}'::eql_v3.jsonb_query`. ---! @see eql_v3.to_ste_vec_query -CREATE DOMAIN eql_v3.jsonb_query AS jsonb - CHECK ( - eql_v3.is_valid_ste_vec_query_payload(VALUE) - ); +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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 -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector text +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord, selector text) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; -CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) - WITH FUNCTION eql_v3.to_ste_vec_query - AS ASSIGNMENT; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector integer +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord, selector integer) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; 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. +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param selector public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- Envelope helpers (eql_v3 owns these; jsonb-only) ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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'); -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; -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 Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param selector public.real_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- Selector extractors ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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 Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord'; 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' -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- Equality-term extractor (XOR-aware: coalesce(hm, oc)) ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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') -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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.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.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.ore_cllw - END -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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 -$$; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- sv-array helpers ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; ---! @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; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; - SELECT array_agg(elem) - INTO ary - FROM jsonb_array_elements(sv) AS elem; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord, b public.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; - RETURN ary; - END; -$$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). ---! @param val jsonb encrypted EQL payload ---! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3.is_ste_vec_array(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'a' THEN - RETURN (val->>'a')::boolean; - END IF; - RETURN false; - END; -$$ LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for public.real_ord_ope. ------------------------------------------------------------------------------- --- Deterministic-fields array for GIN containment ------------------------------------------------------------------------------- +--! @brief Index extractor for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.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 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 - ); -$$; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS - 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.real_ord_ope) $$; ------------------------------------------------------------------------------- --- Containment ------------------------------------------------------------------------------- +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) = eql_v3.ord_ope_term(b) $$; ---! @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 Convenience helper for hand-rolled GIN index expressions over the ---! raw extracted `jsonb[]` array (see database-indexes.md). The typed ---! `eql_v3.json` `@>`/`<@` operators do NOT call this function — they ---! bind to `eql_v3.ste_vec_contains` instead. Public API, reachable ---! only from caller-authored SQL. -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); -$$; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.real_ord_ope) $$; ---! @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 Convenience helper for hand-rolled GIN index expressions over the ---! raw extracted `jsonb[]` array (see database-indexes.md). The typed ---! `eql_v3.json` `@>`/`<@` operators do NOT call this function — they ---! bind to `eql_v3.ste_vec_contains` instead. Public API, reachable ---! only from caller-authored SQL. -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); -$$; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) <> eql_v3.ord_ope_term(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 Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief 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; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.real_ord_ope) $$; - FOR idx IN 1..array_length(a, 1) LOOP - _a := a[idx]; - result := result OR ( - eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) - ); - EXIT WHEN result; - END LOOP; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) < eql_v3.ord_ope_term(b) $$; - RETURN result; - END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief 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); +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.real_ord_ope) $$; - IF array_length(sv_b, 1) IS NULL THEN - RETURN true; - END IF; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; - IF array_length(sv_a, 1) IS NULL THEN - RETURN false; - END IF; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; - result := true; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.real_ord_ope) $$; - 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; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) > eql_v3.ord_ope_term(b) $$; - RETURN result; - END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ------------------------------------------------------------------------------- --- Path queries (text selector only) ------------------------------------------------------------------------------- +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.real_ord_ope) $$; ---! @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 -$$; +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; -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 Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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 - ); -$$; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; -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 Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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 -$$; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; -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)'; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- Array functions ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); - RETURN array_length(sv, 1); - END IF; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector text +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ope, selector text) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - RAISE 'cannot get array length of a non-array'; - END; -$$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector integer +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ope, selector integer) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; 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.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param selector public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord_ope) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - FOR idx IN 1..array_length(sv, 1) LOOP - item = sv[idx]; - RETURN NEXT (meta || item)::eql_v3.jsonb_entry; - END LOOP; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - RETURN; - END; -$$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param selector public.real_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; 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.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - sv := eql_v3.ste_vec(val); +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - FOR idx IN 1..array_length(sv, 1) LOOP - RETURN NEXT eql_v3.ciphertext(sv[idx]); - END LOOP; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - RETURN; - END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE --- Source is src/v3/version.template +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; -DROP FUNCTION IF EXISTS eql_v3.version(); +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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 DEV 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 Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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 'DEV'; -$$ LANGUAGE SQL; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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 'DEV'; +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; ---! @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.ore_block_256`, `eql_v3.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. ---! ---! @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 = 'eql_v3'::regnamespace - ) - ), +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - -- 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 - ), +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ope, b public.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - -- 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 = 'eql_v3' - 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 = 'eql_v3' - ) - ) +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ 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). │ - -- └─────────────────────────────────────────────────────────────────┘ +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. - 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 - ) +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for public.real_ord_ope. - UNION ALL +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - SELECT - 'error', - 'inlinability_volatility', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).', - opname) - FROM op_impl - WHERE volatility = 'v' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - UNION ALL +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - SELECT - 'error', - 'inlinability_set_clause', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.') - FROM op_impl - WHERE config IS NOT NULL - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - UNION ALL +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - SELECT - 'error', - 'inlinability_secdef', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' - FROM op_impl - WHERE secdef - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Transitive inlinability: an operator implementation function │ - -- │ that's itself inlinable can still fail to inline if its body │ - -- │ calls a non-inlinable function. Walk one level via pg_depend. │ - -- │ │ - -- │ Postgres records function-to-function dependencies in │ - -- │ pg_depend with deptype 'n' (normal) when one function references│ - -- │ another in its body — but only at CREATE time and only for │ - -- │ direct calls. This is good enough for v1; deeper transitive │ - -- │ analysis is a follow-up. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - UNION ALL +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - SELECT - 'error', - 'inlinability_transitive', - format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, - oi.impl_signature), - format( - 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.', - called.proname, - called_lang.lanname, - CASE called.provolatile - WHEN 'i' THEN 'IMMUTABLE' - WHEN 's' THEN 'STABLE' - WHEN 'v' THEN 'VOLATILE' - END, - CASE WHEN called.proconfig IS NOT NULL - THEN ', has SET clause' - ELSE '' END) - FROM op_impl oi - -- Only worth the transitive check if the outer function is otherwise - -- inlinable — otherwise the direct lints above already report it. - JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure - JOIN pg_depend d - ON d.classid = 'pg_proc'::regclass - AND d.objid = outer_p.oid - AND d.refclassid = 'pg_proc'::regclass - AND d.deptype = 'n' - JOIN pg_proc called ON called.oid = d.refobjid - JOIN pg_language called_lang ON called_lang.oid = called.prolang - WHERE oi.lang = 'sql' - AND oi.volatility IN ('i', 's') - AND oi.config IS NULL - AND NOT oi.secdef - AND called.oid <> outer_p.oid - AND ( - called_lang.lanname <> 'sql' - OR called.provolatile = 'v' - OR called.proconfig IS NOT NULL - OR called.prosecdef - ) +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ - -- │ have inverted inlinability requirements vs operator impls. │ - -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ - -- │ blocker returns NULL on NULL args. Both silently re-enable │ - -- │ operators the storage variant is supposed to block. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); - UNION ALL +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); - SELECT - 'error', - 'blocker_language', - format('function %s', signature), - format( - 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.', - lang) - FROM encrypted_domain_blockers - WHERE lang <> 'plpgsql' +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); - UNION ALL +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); - SELECT - 'error', - 'blocker_strict', - format('function %s', signature), - 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' - FROM encrypted_domain_blockers - WHERE isstrict +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain identity: an encrypted-domain must be defined directly │ - -- │ over jsonb. Operators resolve against the ultimate base type, │ - -- │ so domain-over-domain inherits jsonb's operator surface and not │ - -- │ the base domain's blockers. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); - UNION ALL +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); - SELECT - 'error', - 'domain_over_domain', - format('domain %I.%I', dn.nspname, dt.typname), - format( - 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.', - dn.nspname, dt.typname, bn.nspname, bt.typname) - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND dn.nspname = 'eql_v3' - AND bt.typtype = 'd' - AND bn.nspname = 'eql_v3' +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain opclass: an operator class declared FOR TYPE on an │ - -- │ encrypted-domain bypasses operator resolution at index time. │ - -- │ Use a functional index on the extractor instead. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); - UNION ALL +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); - 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 = 'eql_v3' +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); - ORDER BY 1, 2, 3; -$$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); -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.'; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_ord_aggregates.sql ---! @brief Aggregates for eql_v3.int4_ord. +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for public.real_ord_ope. ---! @brief State function for min on eql_v3.int4_ord. ---! @param state eql_v3.int4_ord ---! @param value eql_v3.int4_ord ---! @return eql_v3.int4_ord -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.int4_ord, value eql_v3.int4_ord) -RETURNS eql_v3.int4_ord +--! @brief State function for min on public.real_ord_ope. +--! @param state public.real_ord_ope +--! @param value public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord_ope, value public.real_ord_ope) +RETURNS public.real_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -16359,22 +27428,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.int4_ord. ---! @param input eql_v3.int4_ord ---! @return eql_v3.int4_ord -CREATE AGGREGATE eql_v3.min(eql_v3.int4_ord) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.int4_ord, - combinefunc = eql_v3.min_sfunc, +--! @brief min aggregate for public.real_ord_ope. +--! @param input public.real_ord_ope +--! @return public.real_ord_ope +CREATE AGGREGATE eql_v3.min(public.real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.int4_ord. ---! @param state eql_v3.int4_ord ---! @param value eql_v3.int4_ord ---! @return eql_v3.int4_ord -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.int4_ord, value eql_v3.int4_ord) -RETURNS eql_v3.int4_ord +--! @brief State function for max on public.real_ord_ope. +--! @param state public.real_ord_ope +--! @param value public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord_ope, value public.real_ord_ope) +RETURNS public.real_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -16386,4900 +27455,5281 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.int4_ord. ---! @param input eql_v3.int4_ord ---! @return eql_v3.int4_ord -CREATE AGGREGATE eql_v3.max(eql_v3.int4_ord) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.int4_ord, - combinefunc = eql_v3.max_sfunc, +--! @brief max aggregate for public.real_ord_ope. +--! @param input public.real_ord_ope +--! @return public.real_ord_ope +CREATE AGGREGATE eql_v3.max(public.real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_functions.sql ---! @brief Functions for eql_v3.int4. - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_ord_ope_query_functions.sql +--! @brief Functions for public.real_ord_ope_query. ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.real_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int4) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param selector text ---! @return eql_v3.int4 -CREATE FUNCTION eql_v3."->"(a eql_v3.int4, selector text) -RETURNS eql_v3.int4 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param selector integer ---! @return eql_v3.int4 -CREATE FUNCTION eql_v3."->"(a eql_v3.int4, selector integer) -RETURNS eql_v3.int4 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param selector eql_v3.int4 ---! @return eql_v3.int4 -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int4) -RETURNS eql_v3.int4 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param selector eql_v3.int4 ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int4) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int4, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text[] +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int4, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text[] +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int4, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonpath +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int4, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonpath +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int4, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int4, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_ord_ope_query_operators.sql +--! @brief Operators for public.real_ord_ope_query. ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int4, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int4, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b eql_v3.int4 ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4, b eql_v3.int4) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a eql_v3.int4 ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.int4. ---! @param a jsonb ---! @param b eql_v3.int4 ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int4) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_eq_operators.sql ---! @brief Operators for eql_v3.int4_eq. +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for public.real_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb, + LEFTARG = public.real_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb, + LEFTARG = public.real_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord, RIGHTARG = public.real_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for public.real_ord. + +--! @brief State function for min on public.real_ord. +--! @param state public.real_ord +--! @param value public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord, value public.real_ord) +RETURNS public.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 public.real_ord. +--! @param input public.real_ord +--! @return public.real_ord +CREATE AGGREGATE eql_v3.min(public.real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord. +--! @param state public.real_ord +--! @param value public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord, value public.real_ord) +RETURNS public.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 public.real_ord. +--! @param input public.real_ord +--! @return public.real_ord +CREATE AGGREGATE eql_v3.max(public.real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_ord_ore_functions.sql ---! @brief Functions for eql_v3.int4_ord_ore. +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for public.real_ord_ore. ---! @brief Index extractor for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.int4_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.int4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @brief Operator wrapper for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.int4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @brief Operator wrapper for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.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.int4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @brief Operator wrapper for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.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.int4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @brief Operator wrapper for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.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.int4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @brief Operator wrapper for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.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.int4_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.real_ord_ore) $$; ---! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @brief Operator wrapper for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @brief Unsupported operator blocker for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ore, b public.real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @brief Unsupported operator blocker for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param selector text ---! @return eql_v3.int4_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.int4_ord_ore, selector text) -RETURNS eql_v3.int4_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_ord_ore'; END; $$ +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ore, selector text) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param selector integer ---! @return eql_v3.int4_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.int4_ord_ore, selector integer) -RETURNS eql_v3.int4_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_ord_ore'; END; $$ +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ore, selector integer) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @brief Unsupported operator blocker for public.real_ord_ore. --! @param a jsonb ---! @param selector eql_v3.int4_ord_ore ---! @return eql_v3.int4_ord_ore -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int4_ord_ore) -RETURNS eql_v3.int4_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int4_ord_ore'; END; $$ +--! @param selector public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord_ore) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @brief Unsupported operator blocker for public.real_ord_ore. --! @param a jsonb ---! @param selector eql_v3.int4_ord_ore +--! @param selector public.real_ord_ore --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int4_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int4_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int4_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int4_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int4_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int4_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int4_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int4_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore ---! @param b eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ore, b public.real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. ---! @param a eql_v3.int4_ord_ore +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @brief Unsupported operator blocker for public.real_ord_ore. --! @param a jsonb ---! @param b eql_v3.int4_ord_ore +--! @param b public.real_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int4_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_ord_ore_operators.sql ---! @brief Operators for eql_v3.int4_ord_ore. +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for public.real_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_operators.sql ---! @brief Operators for eql_v3.int4. +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for public.real_ord_ore. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +--! @brief State function for min on public.real_ord_ore. +--! @param state public.real_ord_ore +--! @param value public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord_ore, value public.real_ord_ore) +RETURNS public.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 public.real_ord_ore. +--! @param input public.real_ord_ore +--! @return public.real_ord_ore +CREATE AGGREGATE eql_v3.min(public.real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb +--! @brief State function for max on public.real_ord_ore. +--! @param state public.real_ord_ore +--! @param value public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord_ore, value public.real_ord_ore) +RETURNS public.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 public.real_ord_ore. +--! @param input public.real_ord_ore +--! @return public.real_ord_ore +CREATE AGGREGATE eql_v3.max(public.real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_query_functions.sql +--! @brief Functions for public.real_ord_ore_query. + +--! @brief Index extractor for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_query_operators.sql +--! @brief Operators for public.real_ord_ore_query. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); +--! @file encrypted_domain/real/real_ord_query_functions.sql +--! @brief Functions for public.real_ord_query. -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 -); +--! @brief Index extractor for public.real_ord_query. +--! @param a public.real_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int4, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4, RIGHTARG = text -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int4, RIGHTARG = integer -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4, RIGHTARG = text -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int4, RIGHTARG = integer -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int4, RIGHTARG = text -); +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int4, RIGHTARG = text[] -); +--! @file encrypted_domain/real/real_ord_query_operators.sql +--! @brief Operators for public.real_ord_query. -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int4, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int4, RIGHTARG = jsonpath +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int4, RIGHTARG = jsonpath +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int4, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int4, RIGHTARG = text[] +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4, RIGHTARG = text +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4, RIGHTARG = integer +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int4, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int4, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int4, RIGHTARG = jsonb +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int4/int4_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.int4_ord_ore. +--! @file v3/scalars/smallint/smallint_query_types.sql +--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.smallint_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. ---! @brief State function for min on eql_v3.int4_ord_ore. ---! @param state eql_v3.int4_ord_ore ---! @param value eql_v3.int4_ord_ore ---! @return eql_v3.int4_ord_ore -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.int4_ord_ore, value eql_v3.int4_ord_ore) -RETURNS eql_v3.int4_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ +DO $$ BEGIN - IF value < state THEN - RETURN value; + --! @brief Query-operand domain public.smallint_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); END IF; - RETURN state; -END; + + COMMENT ON DOMAIN public.smallint_eq_query IS 'EQL smallint query operand (equality)'; + + --! @brief Query-operand domain public.smallint_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ore_query IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.smallint_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_query IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.smallint_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ope_query IS 'EQL smallint query operand (equality, ordering)'; +END $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.smallint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint IS 'EQL encrypted smallint (storage only)'; + + --! @brief Encrypted domain public.smallint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_eq IS 'EQL encrypted smallint (equality)'; + + --! @brief Encrypted domain public.smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.smallint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 min aggregate for eql_v3.int4_ord_ore. ---! @param input eql_v3.int4_ord_ore ---! @return eql_v3.int4_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.int4_ord_ore) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.int4_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); + COMMENT ON DOMAIN public.smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; ---! @brief State function for max on eql_v3.int4_ord_ore. ---! @param state eql_v3.int4_ord_ore ---! @param value eql_v3.int4_ord_ore ---! @return eql_v3.int4_ord_ore -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.int4_ord_ore, value eql_v3.int4_ord_ore) -RETURNS eql_v3.int4_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; + --! @brief Encrypted domain public.smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; - RETURN state; -END; -$$; ---! @brief max aggregate for eql_v3.int4_ord_ore. ---! @param input eql_v3.int4_ord_ore ---! @return eql_v3.int4_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.int4_ord_ore) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.int4_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); + COMMENT ON DOMAIN public.smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_eq_functions.sql ---! @brief Functions for eql_v3.int2_eq. +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for public.smallint_eq. ---! @brief Index extractor for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.int2_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.smallint_eq. +--! @param a public.smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2_eq, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int2_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.int2_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.smallint_eq) $$; ---! @brief Operator wrapper for eql_v3.int2_eq. +--! @brief Operator wrapper for public.smallint_eq. --! @param a jsonb ---! @param b eql_v3.int2_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.int2_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.smallint_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2_eq, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int2_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.int2_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.smallint_eq) $$; ---! @brief Operator wrapper for eql_v3.int2_eq. +--! @brief Operator wrapper for public.smallint_eq. --! @param a jsonb ---! @param b eql_v3.int2_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.int2_eq) <> eql_v3.eq_term(b) $$; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2_eq, b eql_v3.int2_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int2_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a jsonb ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int2_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2_eq, b eql_v3.int2_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int2_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a jsonb ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int2_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2_eq, b eql_v3.int2_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int2_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a jsonb ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int2_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; +AS $$ SELECT eql_v3.eq_term(a::public.smallint_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2_eq, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.smallint_eq, b public.smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int2_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. +--! @brief Unsupported operator blocker for public.smallint_eq. --! @param a jsonb ---! @param b eql_v3.int2_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2_eq, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.smallint_eq, b public.smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int2_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. +--! @brief Unsupported operator blocker for public.smallint_eq. --! @param a jsonb ---! @param b eql_v3.int2_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_eq, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.smallint_eq, b public.smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a jsonb ---! @param b eql_v3.int2_eq ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int2_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param selector text ---! @return eql_v3.int2_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.int2_eq, selector text) -RETURNS eql_v3.int2_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param selector integer ---! @return eql_v3.int2_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.int2_eq, selector integer) -RETURNS eql_v3.int2_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a jsonb ---! @param selector eql_v3.int2_eq ---! @return eql_v3.int2_eq -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int2_eq) -RETURNS eql_v3.int2_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int2_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. +--! @brief Unsupported operator blocker for public.smallint_eq. --! @param a jsonb ---! @param selector eql_v3.int2_eq ---! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int2_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int2_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int2_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int2_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b jsonpath +--! @param b public.smallint_eq --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int2_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int2_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int2_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int2_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b eql_v3.int2_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2_eq, b eql_v3.int2_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a eql_v3.int2_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int2_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for eql_v3.int2_eq. ---! @param a jsonb ---! @param b eql_v3.int2_eq ---! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/int2/int2_ord_aggregates.sql ---! @brief Aggregates for eql_v3.int2_ord. - ---! @brief State function for min on eql_v3.int2_ord. ---! @param state eql_v3.int2_ord ---! @param value eql_v3.int2_ord ---! @return eql_v3.int2_ord -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.int2_ord, value eql_v3.int2_ord) -RETURNS eql_v3.int2_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.int2_ord. ---! @param input eql_v3.int2_ord ---! @return eql_v3.int2_ord -CREATE AGGREGATE eql_v3.min(eql_v3.int2_ord) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.int2_ord, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.int2_ord. ---! @param state eql_v3.int2_ord ---! @param value eql_v3.int2_ord ---! @return eql_v3.int2_ord -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.int2_ord, value eql_v3.int2_ord) -RETURNS eql_v3.int2_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.int2_ord. ---! @param input eql_v3.int2_ord ---! @return eql_v3.int2_ord -CREATE AGGREGATE eql_v3.max(eql_v3.int2_ord) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.int2_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/int2/int2_operators.sql ---! @brief Operators for eql_v3.int2. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector text +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_eq, selector text) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector integer +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_eq, selector integer) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param selector public.smallint_eq +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_eq) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int2, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param selector public.smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int2, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int2, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int2, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int2, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int2, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int2, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int2, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_eq, b public.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2 -); +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_eq_operators.sql ---! @brief Operators for eql_v3.int2_eq. +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for public.smallint_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int2_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int2_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int2/int2_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.int2_ord_ore. +--! @file encrypted_domain/smallint/smallint_eq_query_functions.sql +--! @brief Functions for public.smallint_eq_query. ---! @brief State function for min on eql_v3.int2_ord_ore. ---! @param state eql_v3.int2_ord_ore ---! @param value eql_v3.int2_ord_ore ---! @return eql_v3.int2_ord_ore -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.int2_ord_ore, value eql_v3.int2_ord_ore) -RETURNS eql_v3.int2_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Index extractor for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief min aggregate for eql_v3.int2_ord_ore. ---! @param input eql_v3.int2_ord_ore ---! @return eql_v3.int2_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.int2_ord_ore) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.int2_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq +--! @param b public.smallint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief State function for max on eql_v3.int2_ord_ore. ---! @param state eql_v3.int2_ord_ore ---! @param value eql_v3.int2_ord_ore ---! @return eql_v3.int2_ord_ore -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.int2_ord_ore, value eql_v3.int2_ord_ore) -RETURNS eql_v3.int2_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq_query, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief max aggregate for eql_v3.int2_ord_ore. ---! @param input eql_v3.int2_ord_ore ---! @return eql_v3.int2_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.int2_ord_ore) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.int2_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq +--! @param b public.smallint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @file encrypted_domain/float8/float8_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.float8_ord_ore. +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq_query, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief State function for min on eql_v3.float8_ord_ore. ---! @param state eql_v3.float8_ord_ore ---! @param value eql_v3.float8_ord_ore ---! @return eql_v3.float8_ord_ore -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.float8_ord_ore, value eql_v3.float8_ord_ore) -RETURNS eql_v3.float8_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/smallint/smallint_eq_query_operators.sql +--! @brief Operators for public.smallint_eq_query. ---! @brief min aggregate for eql_v3.float8_ord_ore. ---! @param input eql_v3.float8_ord_ore ---! @return eql_v3.float8_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.float8_ord_ore) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.float8_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); ---! @brief State function for max on eql_v3.float8_ord_ore. ---! @param state eql_v3.float8_ord_ore ---! @param value eql_v3.float8_ord_ore ---! @return eql_v3.float8_ord_ore -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.float8_ord_ore, value eql_v3.float8_ord_ore) -RETURNS eql_v3.float8_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief max aggregate for eql_v3.float8_ord_ore. ---! @param input eql_v3.float8_ord_ore ---! @return eql_v3.float8_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.float8_ord_ore) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.float8_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_eq_functions.sql ---! @brief Functions for eql_v3.float8_eq. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Index extractor for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.float8_eq) -RETURNS eql_v3.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for public.smallint. ---! @brief Operator wrapper for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8_eq, b eql_v3.float8_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float8_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.float8_eq) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float8_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.float8_eq) = eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8_eq, b eql_v3.float8_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float8_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.float8_eq) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float8_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.float8_eq) <> eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.smallint, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.smallint, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.smallint, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.smallint, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.smallint, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param selector text ---! @return eql_v3.float8_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.float8_eq, selector text) -RETURNS eql_v3.float8_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_eq'; END; $$ +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a public.smallint, selector text) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param selector integer ---! @return eql_v3.float8_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.float8_eq, selector integer) -RETURNS eql_v3.float8_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_eq'; END; $$ +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a public.smallint, selector integer) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param selector eql_v3.float8_eq ---! @return eql_v3.float8_eq -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float8_eq) -RETURNS eql_v3.float8_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float8_eq'; END; $$ +--! @param selector public.smallint +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param selector eql_v3.float8_eq +--! @param selector public.smallint --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float8_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float8_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float8_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq ---! @param b eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8_eq, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.smallint, b public.smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. ---! @param a eql_v3.float8_eq +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @brief Unsupported operator blocker for public.smallint. --! @param a jsonb ---! @param b eql_v3.float8_eq +--! @param b public.smallint --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float8_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_ord_operators.sql ---! @brief Operators for eql_v3.float8_ord. +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for public.smallint. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint, RIGHTARG = public.smallint ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_ord_aggregates.sql ---! @brief Aggregates for eql_v3.float8_ord. +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for public.smallint_ord. ---! @brief State function for min on eql_v3.float8_ord. ---! @param state eql_v3.float8_ord ---! @param value eql_v3.float8_ord ---! @return eql_v3.float8_ord -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.float8_ord, value eql_v3.float8_ord) -RETURNS eql_v3.float8_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 Index extractor for public.smallint_ord. +--! @param a public.smallint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector text +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord, selector text) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector integer +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord, selector integer) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param selector public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param selector public.smallint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief min aggregate for eql_v3.float8_ord. ---! @param input eql_v3.float8_ord ---! @return eql_v3.float8_ord -CREATE AGGREGATE eql_v3.min(eql_v3.float8_ord) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.float8_ord, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for max on eql_v3.float8_ord. ---! @param state eql_v3.float8_ord ---! @param value eql_v3.float8_ord ---! @return eql_v3.float8_ord -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.float8_ord, value eql_v3.float8_ord) -RETURNS eql_v3.float8_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord, b public.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; ---! @brief max aggregate for eql_v3.float8_ord. ---! @param input eql_v3.float8_ord ---! @return eql_v3.float8_ord -CREATE AGGREGATE eql_v3.max(eql_v3.float8_ord) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.float8_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_operators.sql ---! @brief Operators for eql_v3.float8. +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for public.smallint_ord_ope. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Index extractor for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.smallint_ord_ope) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.smallint_ord_ope) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.smallint_ord_ope) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.smallint_ord_ope) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.smallint_ord_ope) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.smallint_ord_ope) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector text +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ope, selector text) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector integer +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ope, selector integer) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param selector public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord_ope) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float8, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param selector public.smallint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float8, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float8, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float8, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float8, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float8, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float8, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float8, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8 -); +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float8/float8_eq_operators.sql ---! @brief Operators for eql_v3.float8_eq. +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for public.smallint_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float8_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float8_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope ); -- 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.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) -RETURNS eql_v3.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql +--! @brief Aggregates for public.smallint_ord_ope. ---! @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 State function for min on public.smallint_ord_ope. +--! @param state public.smallint_ord_ope +--! @param value public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord_ope, value public.smallint_ord_ope) +RETURNS public.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 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 min aggregate for public.smallint_ord_ope. +--! @param input public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE AGGREGATE eql_v3.min(public.smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @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 State function for max on public.smallint_ord_ope. +--! @param state public.smallint_ord_ope +--! @param value public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord_ope, value public.smallint_ord_ope) +RETURNS public.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 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 max aggregate for public.smallint_ord_ope. +--! @param input public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE AGGREGATE eql_v3.max(public.smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @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) $$; +--! @file encrypted_domain/smallint/smallint_ord_ope_query_functions.sql +--! @brief Functions for public.smallint_ord_ope_query. ---! @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 Index extractor for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope_query) +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. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope_query, b public.smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope_query, b public.smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope_query, b public.smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope_query, b public.smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope_query, b public.smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope_query, b public.smallint_ord_ope) 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.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.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.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.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.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.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."->"(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."->"(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."->"(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."->>"(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."->>"(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."->>"(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."?"(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; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(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; +--! @file encrypted_domain/smallint/smallint_ord_ope_query_operators.sql +--! @brief Operators for public.smallint_ord_ope_query. ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(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; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(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; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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."||"(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; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a eql_v3.date_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for eql_v3.date_ord. ---! @param a jsonb ---! @param b eql_v3.date_ord ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for eql_v3.date_eq. +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for public.smallint_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.date_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for eql_v3.date. +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for public.smallint_ord. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief State function for min on public.smallint_ord. +--! @param state public.smallint_ord +--! @param value public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord, value public.smallint_ord) +RETURNS public.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; +$$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb +--! @brief min aggregate for public.smallint_ord. +--! @param input public.smallint_ord +--! @return public.smallint_ord +CREATE AGGREGATE eql_v3.min(public.smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief State function for max on public.smallint_ord. +--! @param state public.smallint_ord +--! @param value public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord, value public.smallint_ord) +RETURNS public.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; +$$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +--! @brief max aggregate for public.smallint_ord. +--! @param input public.smallint_ord +--! @return public.smallint_ord +CREATE AGGREGATE eql_v3.max(public.smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for public.smallint_ord_ore. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Index extractor for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.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) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.smallint_ord_ore) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.smallint_ord_ore) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.smallint_ord_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) < eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.smallint_ord_ore) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.smallint_ord_ore) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.smallint_ord_ore) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.date, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector text +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ore, selector text) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector integer +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ore, selector integer) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param selector public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord_ore) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.date, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param selector public.smallint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.date, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @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.min_sfunc, - stype = eql_v3.date_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @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.max_sfunc, - stype = eql_v3.date_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for eql_v3.date_ord. +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for public.smallint_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.date_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore ); -- 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.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for public.smallint_ord_ore. + +--! @brief State function for min on public.smallint_ord_ore. +--! @param state public.smallint_ord_ore +--! @param value public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord_ore, value public.smallint_ord_ore) +RETURNS public.smallint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -21291,22 +32741,22 @@ BEGIN 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.min_sfunc, - stype = eql_v3.date_ord, - combinefunc = eql_v3.min_sfunc, +--! @brief min aggregate for public.smallint_ord_ore. +--! @param input public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE AGGREGATE eql_v3.min(public.smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord_ore, + 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.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) -RETURNS eql_v3.date_ord +--! @brief State function for max on public.smallint_ord_ore. +--! @param state public.smallint_ord_ore +--! @param value public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord_ore, value public.smallint_ord_ore) +RETURNS public.smallint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -21318,3352 +32768,4231 @@ BEGIN 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.max_sfunc, - stype = eql_v3.date_ord, - combinefunc = eql_v3.max_sfunc, +--! @brief max aggregate for public.smallint_ord_ore. +--! @param input public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE AGGREGATE eql_v3.max(public.smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for eql_v3.numeric_ord. +--! @file encrypted_domain/smallint/smallint_ord_ore_query_functions.sql +--! @brief Functions for public.smallint_ord_ore_query. ---! @brief Index extractor for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +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 +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore_query) RETURNS boolean 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 +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore_query, b public.smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; +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 eql_v3.numeric_ord +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore_query, b public.smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore_query) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore_query, b public.smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_query_operators.sql +--! @brief Operators for public.smallint_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord +--! @file encrypted_domain/smallint/smallint_ord_query_functions.sql +--! @brief Functions for public.smallint_ord_query. + +--! @brief Index extractor for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_query, b public.smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for 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 public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_query_operators.sql +--! @brief Operators for public.smallint_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @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) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @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) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @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) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @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) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @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) $$; +--! @file v3/scalars/text/text_query_types.sql +--! @brief Query-operand domains for text (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.text_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. ---! @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) $$; +DO $$ +BEGIN + --! @brief Query-operand domain public.text_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.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; + COMMENT ON DOMAIN public.text_eq_query IS 'EQL text query operand (equality)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.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 Query-operand domain public.text_match_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_match_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.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; + COMMENT ON DOMAIN public.text_match_query IS 'EQL text query operand (containment)'; ---! @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.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 Query-operand domain public.text_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.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; + COMMENT ON DOMAIN public.text_ord_ore_query IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.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 Query-operand domain public.text_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector text ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3."->"(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; + COMMENT ON DOMAIN public.text_ord_query IS 'EQL text query operand (equality, ordering)'; ---! @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."->"(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 Query-operand domain public.text_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return eql_v3.numeric_ord -CREATE FUNCTION eql_v3."->"(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; + COMMENT ON DOMAIN public.text_ord_ope_query IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3."->>"(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 Query-operand domain public.text_search_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_search_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3."->>"(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; + COMMENT ON DOMAIN public.text_search_query IS 'EQL text query operand (equality, ordering, containment)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param selector eql_v3.numeric_ord ---! @return text -CREATE FUNCTION eql_v3."->>"(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; +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3."?"(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; +DO $$ +BEGIN + --! @brief Encrypted domain public.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?|"(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; + COMMENT ON DOMAIN public.text IS 'EQL encrypted text (storage only)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3."?&"(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 Encrypted domain public.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@?"(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; + COMMENT ON DOMAIN public.text_eq IS 'EQL encrypted text (equality)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3."@@"(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 Encrypted domain public.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#>"(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; + COMMENT ON DOMAIN public.text_match IS 'EQL encrypted text (containment)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3."#>>"(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 Encrypted domain public.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; + COMMENT ON DOMAIN public.text_ord_ore IS 'EQL encrypted text (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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 Encrypted domain public.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."-"(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; + COMMENT ON DOMAIN public.text_ord IS 'EQL encrypted text (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3."#-"(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 Encrypted domain public.text_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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 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."||"(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; + COMMENT ON DOMAIN public.text_ord_ope IS 'EQL encrypted text (equality, ordering)'; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a eql_v3.numeric_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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 Encrypted domain public.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; ---! @brief Unsupported operator blocker for eql_v3.numeric_ord. ---! @param a jsonb ---! @param b eql_v3.numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3."||"(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; + COMMENT ON DOMAIN public.text_search IS 'EQL encrypted text (equality, ordering, containment)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for eql_v3.numeric. +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for public.text_eq. + +--! @brief Index extractor for public.text_eq. +--! @param a public.text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a public.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_eq) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Operator wrapper for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_eq) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a public.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_eq) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Operator wrapper for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.lt(a public.text_eq, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.lte(a public.text_eq, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.gt(a public.text_eq, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.gte(a public.text_eq, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.contains(a public.text_eq, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_eq, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param selector text ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.text_eq, selector text) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param selector integer ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.text_eq, selector integer) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param selector eql_v3.numeric ---! @return eql_v3.numeric -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.text_eq +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_eq) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param selector eql_v3.numeric +--! @param selector public.text_eq --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.numeric) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.numeric, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.numeric, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.numeric, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.numeric, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.numeric, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.numeric, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.numeric, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.numeric, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.numeric, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.numeric, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.numeric, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric ---! @param b eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.numeric, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal."||"(a public.text_eq, b public.text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. ---! @param a eql_v3.numeric +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.numeric, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.numeric. +--! @brief Unsupported operator blocker for public.text_eq. --! @param a jsonb ---! @param b eql_v3.numeric +--! @param b public.text_eq --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.numeric) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for eql_v3.numeric_eq. +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for public.text_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + LEFTARG = public.text_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = jsonb, RIGHTARG = public.text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + LEFTARG = public.text_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + LEFTARG = jsonb, RIGHTARG = public.text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_eq, RIGHTARG = public.text_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_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.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; -$$; +--! @file encrypted_domain/text/text_eq_query_functions.sql +--! @brief Functions for public.text_eq_query. ---! @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.min_sfunc, - stype = eql_v3.numeric_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Index extractor for public.text_eq_query. +--! @param a public.text_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief State function for 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.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 Operator wrapper for public.text_eq_query. +--! @param a public.text_eq +--! @param b public.text_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @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.max_sfunc, - stype = eql_v3.numeric_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq_query +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq_query, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for eql_v3.numeric. +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq +--! @param b public.text_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq_query) +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.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq_query +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq_query, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_query_operators.sql +--! @brief Operators for public.text_eq_query. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric + LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric + LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb + LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for public.text. -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector text +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a public.text, selector text) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector integer +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a public.text, selector integer) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param selector public.text +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param selector public.text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.numeric, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/numeric/numeric_ord_operators.sql ---! @brief Operators for eql_v3.numeric_ord. +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text, b public.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for public.text_match. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Index extractor for public.text_match. +--! @param a public.text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.text_match) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Operator wrapper for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_match) @> eql_v3.match_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.text_match) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Operator wrapper for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_match) <@ eql_v3.match_term(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector text +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a public.text_match, selector text) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector integer +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a public.text_match, selector integer) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param selector public.text_match +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_match) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param selector public.text_match +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; ---! @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.min_sfunc, - stype = eql_v3.numeric_ord, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_match, b public.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; ---! @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.max_sfunc, - stype = eql_v3.numeric_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bool/bool_operators.sql ---! @brief Operators for eql_v3.bool. +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for public.text_match. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR @> ( FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + LEFTARG = public.text_match, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + LEFTARG = public.text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + LEFTARG = jsonb, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + LEFTARG = public.text_match, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + LEFTARG = public.text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + LEFTARG = jsonb, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.bool, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_match, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.bool, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_match, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.bool, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_match, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.bool, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_match, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_match ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.bool, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_match, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.bool, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_match, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.bool, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_match, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.bool, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_match, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.bool, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_match, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.bool, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_match, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.bool, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_match, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.bool, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.bool, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.bool, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.bool, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_match, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_match, RIGHTARG = public.text_match ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.bool, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_match, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.bool + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_query_functions.sql +--! @brief Functions for public.text_match_query. + +--! @brief Index extractor for public.text_match_query. +--! @param a public.text_match_query +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_match_query) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match +--! @param b public.text_match_query +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match_query +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match_query, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match +--! @param b public.text_match_query +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match_query +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match_query, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_query_operators.sql +--! @brief Operators for public.text_match_query. + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = public.text_match_query, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match_query, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = public.text_match_query, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match_query, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_operators.sql ---! @brief Operators for eql_v3.int8. +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for public.text. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int8, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int8, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int8, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int8, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int8, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int8, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int8, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int8, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text, RIGHTARG = public.text ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8 + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_eq_functions.sql ---! @brief Functions for eql_v3.int8_eq. +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for public.text_ord. + +--! @brief Index extractor for public.text_ord. +--! @param a public.text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.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.int8_eq. ---! @param a eql_v3.int8_eq ---! @return eql_v3.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.int8_eq) -RETURNS eql_v3.hmac_256 +--! @brief Index extractor for public.text_ord. +--! @param a public.text_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8_eq, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.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.int8_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord) $$; ---! @brief Operator wrapper for eql_v3.int8_eq. +--! @brief Operator wrapper for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.int8_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.text_ord) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8_eq, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.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.int8_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord) $$; ---! @brief Operator wrapper for eql_v3.int8_eq. +--! @brief Operator wrapper for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::eql_v3.int8_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.text_ord) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8_eq, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Operator wrapper for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8_eq, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Operator wrapper for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8_eq, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Operator wrapper for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8_eq, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_ord) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Operator wrapper for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int8_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.int8_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8_eq, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord, b public.text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Unsupported operator blocker for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_eq, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord, b public.text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Unsupported operator blocker for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param selector text ---! @return eql_v3.int8_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.int8_eq, selector text) -RETURNS eql_v3.int8_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_eq'; END; $$ +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord, selector text) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param selector integer ---! @return eql_v3.int8_eq -CREATE FUNCTION eql_v3."->"(a eql_v3.int8_eq, selector integer) -RETURNS eql_v3.int8_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_eq'; END; $$ +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord, selector integer) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Unsupported operator blocker for public.text_ord. --! @param a jsonb ---! @param selector eql_v3.int8_eq ---! @return eql_v3.int8_eq -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int8_eq) -RETURNS eql_v3.int8_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_eq'; END; $$ +--! @param selector public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Unsupported operator blocker for public.text_ord. --! @param a jsonb ---! @param selector eql_v3.int8_eq +--! @param selector public.text_ord --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int8_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int8_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int8_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int8_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq ---! @param b eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8_eq, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord, b public.text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. ---! @param a eql_v3.int8_eq +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @brief Unsupported operator blocker for public.text_ord. --! @param a jsonb ---! @param b eql_v3.int8_eq +--! @param b public.text_ord --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int8_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_ord_ore_functions.sql ---! @brief Functions for eql_v3.int8_ord_ore. +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for public.text_ord_ope. + +--! @brief Index extractor for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.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.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @return eql_v3.ore_block_256 -CREATE FUNCTION eql_v3.ord_term(a eql_v3.int8_ord_ore) -RETURNS eql_v3.ore_block_256 +--! @brief Index extractor for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.int8_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @brief Operator wrapper for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord_ore) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ope) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.int8_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @brief Operator wrapper for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord_ore) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ope) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.int8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @brief Operator wrapper for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord_ore) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) < eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.int8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @brief Operator wrapper for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord_ore) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.int8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @brief Operator wrapper for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord_ore) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) > eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.int8_ord_ore) $$; +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.text_ord_ope) $$; ---! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @brief Operator wrapper for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::eql_v3.int8_ord_ore) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @brief Unsupported operator blocker for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ope, b public.text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @brief Unsupported operator blocker for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param selector text ---! @return eql_v3.int8_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.int8_ord_ore, selector text) -RETURNS eql_v3.int8_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_ord_ore'; END; $$ +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ope, selector text) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param selector integer ---! @return eql_v3.int8_ord_ore -CREATE FUNCTION eql_v3."->"(a eql_v3.int8_ord_ore, selector integer) -RETURNS eql_v3.int8_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_ord_ore'; END; $$ +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ope, selector integer) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @brief Unsupported operator blocker for public.text_ord_ope. --! @param a jsonb ---! @param selector eql_v3.int8_ord_ore ---! @return eql_v3.int8_ord_ore -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.int8_ord_ore) -RETURNS eql_v3.int8_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.int8_ord_ore'; END; $$ +--! @param selector public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord_ope) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @brief Unsupported operator blocker for public.text_ord_ope. --! @param a jsonb ---! @param selector eql_v3.int8_ord_ore +--! @param selector public.text_ord_ope --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.int8_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.int8_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.int8_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.int8_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.int8_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.int8_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.int8_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.int8_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore ---! @param b eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ope, b public.text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. ---! @param a eql_v3.int8_ord_ore +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.int8_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @brief Unsupported operator blocker for public.text_ord_ope. --! @param a jsonb ---! @param b eql_v3.int8_ord_ore +--! @param b public.text_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int8_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_ord_operators.sql ---! @brief Operators for eql_v3.int8_ord. +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for public.text_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8_ord, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for public.text_ord_ope. + +--! @brief State function for min on public.text_ord_ope. +--! @param state public.text_ord_ope +--! @param value public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord_ope, value public.text_ord_ope) +RETURNS public.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 public.text_ord_ope. +--! @param input public.text_ord_ope +--! @return public.text_ord_ope +CREATE AGGREGATE eql_v3.min(public.text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord_ope. +--! @param state public.text_ord_ope +--! @param value public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord_ope, value public.text_ord_ope) +RETURNS public.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 public.text_ord_ope. +--! @param input public.text_ord_ope +--! @return public.text_ord_ope +CREATE AGGREGATE eql_v3.max(public.text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_query_functions.sql +--! @brief Functions for public.text_ord_ope_query. + +--! @brief Index extractor for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ope_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_query_operators.sql +--! @brief Operators for public.text_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_ord, RIGHTARG = integer +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_ord_ore_operators.sql ---! @brief Operators for eql_v3.int8_ord_ore. +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for public.text_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord, RIGHTARG = public.text_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.int8_ord_ore. - ---! @brief State function for min on eql_v3.int8_ord_ore. ---! @param state eql_v3.int8_ord_ore ---! @param value eql_v3.int8_ord_ore ---! @return eql_v3.int8_ord_ore -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.int8_ord_ore, value eql_v3.int8_ord_ore) -RETURNS eql_v3.int8_ord_ore +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for public.text_ord. + +--! @brief State function for min on public.text_ord. +--! @param state public.text_ord +--! @param value public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord, value public.text_ord) +RETURNS public.text_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24675,22 +37004,22 @@ BEGIN END; $$; ---! @brief min aggregate for eql_v3.int8_ord_ore. ---! @param input eql_v3.int8_ord_ore ---! @return eql_v3.int8_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.int8_ord_ore) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.int8_ord_ore, - combinefunc = eql_v3.min_sfunc, +--! @brief min aggregate for public.text_ord. +--! @param input public.text_ord +--! @return public.text_ord +CREATE AGGREGATE eql_v3.min(public.text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord, + combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on eql_v3.int8_ord_ore. ---! @param state eql_v3.int8_ord_ore ---! @param value eql_v3.int8_ord_ore ---! @return eql_v3.int8_ord_ore -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.int8_ord_ore, value eql_v3.int8_ord_ore) -RETURNS eql_v3.int8_ord_ore +--! @brief State function for max on public.text_ord. +--! @param state public.text_ord +--! @param value public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord, value public.text_ord) +RETURNS public.text_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24702,1422 +37031,1756 @@ BEGIN END; $$; ---! @brief max aggregate for eql_v3.int8_ord_ore. ---! @param input eql_v3.int8_ord_ore ---! @return eql_v3.int8_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.int8_ord_ore) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.int8_ord_ore, - combinefunc = eql_v3.max_sfunc, +--! @brief max aggregate for public.text_ord. +--! @param input public.text_ord +--! @return public.text_ord +CREATE AGGREGATE eql_v3.max(public.text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord, + combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_ord_aggregates.sql ---! @brief Aggregates for eql_v3.int8_ord. +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for public.text_ord_ore. ---! @brief State function for min on eql_v3.int8_ord. ---! @param state eql_v3.int8_ord ---! @param value eql_v3.int8_ord ---! @return eql_v3.int8_ord -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.int8_ord, value eql_v3.int8_ord) -RETURNS eql_v3.int8_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 Index extractor for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief min aggregate for eql_v3.int8_ord. ---! @param input eql_v3.int8_ord ---! @return eql_v3.int8_ord -CREATE AGGREGATE eql_v3.min(eql_v3.int8_ord) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.int8_ord, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Index extractor for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief State function for max on eql_v3.int8_ord. ---! @param state eql_v3.int8_ord ---! @param value eql_v3.int8_ord ---! @return eql_v3.int8_ord -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.int8_ord, value eql_v3.int8_ord) -RETURNS eql_v3.int8_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief max aggregate for eql_v3.int8_ord. ---! @param input eql_v3.int8_ord ---! @return eql_v3.int8_ord -CREATE AGGREGATE eql_v3.max(eql_v3.int8_ord) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.int8_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector text +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ore, selector text) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector integer +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ore, selector integer) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param selector public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord_ore) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param selector public.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ore, b public.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/int8/int8_eq_operators.sql ---! @brief Operators for eql_v3.int8_eq. +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for public.text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.int8_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.int8_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore ); -- 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.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.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.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.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.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.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.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.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.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.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.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; +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for public.text_ord_ore. + +--! @brief State function for min on public.text_ord_ore. +--! @param state public.text_ord_ore +--! @param value public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord_ore, value public.text_ord_ore) +RETURNS public.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 Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3.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 min aggregate for public.text_ord_ore. +--! @param input public.text_ord_ore +--! @return public.text_ord_ore +CREATE AGGREGATE eql_v3.min(public.text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3.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 State function for max on public.text_ord_ore. +--! @param state public.text_ord_ore +--! @param value public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord_ore, value public.text_ord_ore) +RETURNS public.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 Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.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 max aggregate for public.text_ord_ore. +--! @param input public.text_ord_ore +--! @return public.text_ord_ore +CREATE AGGREGATE eql_v3.max(public.text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3.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; +--! @file encrypted_domain/text/text_ord_ore_query_functions.sql +--! @brief Functions for public.text_ord_ore_query. ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text ---! @return boolean -CREATE FUNCTION eql_v3.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 Index extractor for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.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 Index extractor for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b eql_v3.text +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonb +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a jsonb ---! @param b eql_v3.text +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3.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."->"(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."->"(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."->"(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."->>"(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."->>"(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."->>"(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; +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3."?"(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; +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3."?|"(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; +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b text[] +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3."?&"(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; +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonpath +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query --! @return boolean -CREATE FUNCTION eql_v3."@?"(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; +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.text. ---! @param a eql_v3.text ---! @param b jsonpath +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3."@@"(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."#>"(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."#>>"(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."-"(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."-"(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."-"(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."#-"(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."||"(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."||"(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."||"(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; +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for eql_v3.text_match. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); +--! @file encrypted_domain/text/text_ord_ore_query_operators.sql +--! @brief Operators for public.text_ord_ore_query. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.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."->", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_match, RIGHTARG = integer + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); +--! @file encrypted_domain/text/text_ord_query_functions.sql +--! @brief Functions for public.text_ord_query. -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); +--! @brief Index extractor for public.text_ord_query. +--! @param a public.text_ord_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); +--! @brief Index extractor for public.text_ord_query. +--! @param a public.text_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord_query) +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."@?", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord_query) +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."#>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_match, RIGHTARG = integer -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_match, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_match -); +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/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 -); +--! @file encrypted_domain/text/text_ord_query_operators.sql +--! @brief Operators for public.text_ord_query. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, 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, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, 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, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, 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, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, 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, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for public.text_search. -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_search) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_search) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.text_search) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_search) @> eql_v3.match_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.text_search) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_search) <@ eql_v3.match_term(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector text +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a public.text_search, selector text) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector integer +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a public.text_search, selector integer) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param selector public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_search) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param selector public.text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_search, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.text_search, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_search, b public.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_search, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_search -); +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_operators.sql ---! @brief Operators for eql_v3.text_eq. +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for public.text_search. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + LEFTARG = public.text_search, RIGHTARG = public.text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + LEFTARG = public.text_search, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + LEFTARG = jsonb, RIGHTARG = public.text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + LEFTARG = public.text_search, RIGHTARG = public.text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + LEFTARG = public.text_search, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + LEFTARG = jsonb, RIGHTARG = public.text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR <@ ( FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_search, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_search, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_search ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_search, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_search, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_search ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.text_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_search, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_search, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_search, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_search, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_search, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_search, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_search, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.text_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_search, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_search, RIGHTARG = public.text_search ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_search, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_search ); -- 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.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for public.text_search. + +--! @brief State function for min on public.text_search. +--! @param state public.text_search +--! @param value public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_search, value public.text_search) +RETURNS public.text_search LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -26129,22 +38792,22 @@ BEGIN 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.min_sfunc, - stype = eql_v3.text_ord_ore, - combinefunc = eql_v3.min_sfunc, +--! @brief min aggregate for public.text_search. +--! @param input public.text_search +--! @return public.text_search +CREATE AGGREGATE eql_v3.min(public.text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_search, + 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.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) -RETURNS eql_v3.text_ord_ore +--! @brief State function for max on public.text_search. +--! @param state public.text_search +--! @param value public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_search, value public.text_search) +RETURNS public.text_search LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -26156,3522 +38819,4409 @@ BEGIN 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.max_sfunc, - stype = eql_v3.text_ord_ore, - combinefunc = eql_v3.max_sfunc, +--! @brief max aggregate for public.text_search. +--! @param input public.text_search +--! @return public.text_search +CREATE AGGREGATE eql_v3.max(public.text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_search, + 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.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; -$$; +--! @file encrypted_domain/text/text_search_query_functions.sql +--! @brief Functions for public.text_search_query. ---! @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.min_sfunc, - stype = eql_v3.text_ord, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_search_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief State function for 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.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 Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_search_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_search_query) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; ---! @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.max_sfunc, - stype = eql_v3.text_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for eql_v3.text. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); +--! @file encrypted_domain/text/text_search_query_operators.sql +--! @brief Operators for public.text_search_query. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.text + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.text, RIGHTARG = jsonb + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.text +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_query_types.sql +--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.timestamp_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.timestamp_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_eq_query IS 'EQL timestamp query operand (equality)'; + + --! @brief Query-operand domain public.timestamp_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ore_query IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain public.timestamp_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_query IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain public.timestamp_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ope_query IS 'EQL timestamp query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + +DO $$ +BEGIN + --! @brief Encrypted domain public.timestamp. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp IS 'EQL encrypted timestamp (storage only)'; + + --! @brief Encrypted domain public.timestamp_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_eq IS 'EQL encrypted timestamp (equality)'; + + --! @brief Encrypted domain public.timestamp_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.timestamp_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.timestamp_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for public.timestamp_eq. + +--! @brief Index extractor for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.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 public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.timestamp_eq) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.timestamp_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.timestamp_eq) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.timestamp_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.text, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.text, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector text +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_eq, selector text) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector integer +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_eq, selector integer) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.text, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param selector public.timestamp_eq +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_eq) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param selector public.timestamp_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.text, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.text, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.text, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.text -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @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.min_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_eq, b public.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @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.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 Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @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.max_sfunc, - stype = eql_v3.text_search, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_eq_operators.sql ---! @brief Operators for eql_v3.float4_eq. +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for public.timestamp_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_ord_ore_aggregates.sql ---! @brief Aggregates for eql_v3.float4_ord_ore. +--! @file encrypted_domain/timestamp/timestamp_eq_query_functions.sql +--! @brief Functions for public.timestamp_eq_query. ---! @brief State function for min on eql_v3.float4_ord_ore. ---! @param state eql_v3.float4_ord_ore ---! @param value eql_v3.float4_ord_ore ---! @return eql_v3.float4_ord_ore -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.float4_ord_ore, value eql_v3.float4_ord_ore) -RETURNS eql_v3.float4_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Index extractor for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.timestamp_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief min aggregate for eql_v3.float4_ord_ore. ---! @param input eql_v3.float4_ord_ore ---! @return eql_v3.float4_ord_ore -CREATE AGGREGATE eql_v3.min(eql_v3.float4_ord_ore) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.float4_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq_query, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq_query, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_query_operators.sql +--! @brief Operators for public.timestamp_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); ---! @brief State function for max on eql_v3.float4_ord_ore. ---! @param state eql_v3.float4_ord_ore ---! @param value eql_v3.float4_ord_ore ---! @return eql_v3.float4_ord_ore -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.float4_ord_ore, value eql_v3.float4_ord_ore) -RETURNS eql_v3.float4_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.float4_ord_ore. ---! @param input eql_v3.float4_ord_ore ---! @return eql_v3.float4_ord_ore -CREATE AGGREGATE eql_v3.max(eql_v3.float4_ord_ore) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.float4_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_functions.sql ---! @brief Functions for eql_v3.float4. +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for public.timestamp. ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.eq(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.neq(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param selector text ---! @return eql_v3.float4 -CREATE FUNCTION eql_v3."->"(a eql_v3.float4, selector text) -RETURNS eql_v3.float4 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4'; END; $$ +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp, selector text) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param selector integer ---! @return eql_v3.float4 -CREATE FUNCTION eql_v3."->"(a eql_v3.float4, selector integer) -RETURNS eql_v3.float4 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4'; END; $$ +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp, selector integer) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param selector eql_v3.float4 ---! @return eql_v3.float4 -CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.float4) -RETURNS eql_v3.float4 IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.float4'; END; $$ +--! @param selector public.timestamp +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.float4, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param selector eql_v3.float4 +--! @param selector public.timestamp --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float4) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.float4, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.float4, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.float4, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.float4, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.float4, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.float4, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.float4, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.float4, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.float4, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 ---! @param b eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp, b public.timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. ---! @param a eql_v3.float4 +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.float4, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.float4. +--! @brief Unsupported operator blocker for public.timestamp. --! @param a jsonb ---! @param b eql_v3.float4 +--! @param b public.timestamp --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float4) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/float4/float4_ord_aggregates.sql ---! @brief Aggregates for eql_v3.float4_ord. - ---! @brief State function for min on eql_v3.float4_ord. ---! @param state eql_v3.float4_ord ---! @param value eql_v3.float4_ord ---! @return eql_v3.float4_ord -CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.float4_ord, value eql_v3.float4_ord) -RETURNS eql_v3.float4_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.float4_ord. ---! @param input eql_v3.float4_ord ---! @return eql_v3.float4_ord -CREATE AGGREGATE eql_v3.min(eql_v3.float4_ord) ( - sfunc = eql_v3.min_sfunc, - stype = eql_v3.float4_ord, - combinefunc = eql_v3.min_sfunc, - parallel = safe -); - ---! @brief State function for max on eql_v3.float4_ord. ---! @param state eql_v3.float4_ord ---! @param value eql_v3.float4_ord ---! @return eql_v3.float4_ord -CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.float4_ord, value eql_v3.float4_ord) -RETURNS eql_v3.float4_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.float4_ord. ---! @param input eql_v3.float4_ord ---! @return eql_v3.float4_ord -CREATE AGGREGATE eql_v3.max(eql_v3.float4_ord) ( - sfunc = eql_v3.max_sfunc, - stype = eql_v3.float4_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/float4/float4_operators.sql ---! @brief Operators for eql_v3.float4. +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for public.timestamp. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.float4, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.float4, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.float4, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.float4, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.float4, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.float4, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.float4, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.float4, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.float4, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for public.timestamp_ord. + +--! @brief Index extractor for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector text +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord, selector text) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector integer +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord, selector integer) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param selector public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param selector public.timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.float4, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.float4, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.float4, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord, b public.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.float4, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.float4 -); +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for eql_v3.timestamp. +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for public.timestamp_ord_ope. ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Index extractor for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a public.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::public.timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Operator wrapper for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a public.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::public.timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Operator wrapper for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a public.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::public.timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Operator wrapper for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a public.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::public.timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Operator wrapper for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a public.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::public.timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Operator wrapper for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gte(a public.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::public.timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Operator wrapper for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.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; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ope, b public.timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ope, b public.timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param selector text ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ope, selector text) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param selector integer ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3."->"(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; $$ +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ope, selector integer) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. --! @param a jsonb ---! @param selector eql_v3.timestamp ---! @return eql_v3.timestamp -CREATE FUNCTION eql_v3."->"(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; $$ +--! @param selector public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamp, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamp, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. --! @param a jsonb ---! @param selector eql_v3.timestamp +--! @param selector public.timestamp_ord_ope --! @return text -CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3."?"(a eql_v3.timestamp, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."-"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp ---! @param b eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.timestamp, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ope, b public.timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. ---! @param a eql_v3.timestamp +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3."||"(a eql_v3.timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. --! @param a jsonb ---! @param b eql_v3.timestamp +--! @param b public.timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamp) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; -- 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.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.min_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3.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.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.max_sfunc, - stype = eql_v3.timestamp_ord, - combinefunc = eql_v3.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for eql_v3.timestamp_eq. +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for public.timestamp_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for public.timestamp_ord_ope. + +--! @brief State function for min on public.timestamp_ord_ope. +--! @param state public.timestamp_ord_ope +--! @param value public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord_ope, value public.timestamp_ord_ope) +RETURNS public.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 public.timestamp_ord_ope. +--! @param input public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(public.timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord_ope. +--! @param state public.timestamp_ord_ope +--! @param value public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord_ope, value public.timestamp_ord_ope) +RETURNS public.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 public.timestamp_ord_ope. +--! @param input public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(public.timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_query_functions.sql +--! @brief Functions for public.timestamp_ord_ope_query. + +--! @brief Index extractor for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath -); +--! @file encrypted_domain/timestamp/timestamp_ord_ope_query_operators.sql +--! @brief Operators for public.timestamp_ord_ope_query. -CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); --- 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.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.min_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3.min_sfunc, - parallel = safe +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); ---! @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.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.max_sfunc, - stype = eql_v3.timestamp_ord_ore, - combinefunc = eql_v3.max_sfunc, - parallel = safe +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for eql_v3.timestamp. +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for public.timestamp_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = text + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3."->", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3."->>", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3."?", - LEFTARG = eql_v3.timestamp, RIGHTARG = text + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3."?|", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3."?&", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3."@?", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3."@@", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3."#>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3."#>>", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3."-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3."#-", - LEFTARG = eql_v3.timestamp, RIGHTARG = text[] + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3."||", - LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp -); - ---! @file v3/sem/ore_block_256/operator_class.sql ---! @brief B-tree operator family + default class on eql_v3.ore_block_256. ---! ---! Gives the composite type its DEFAULT btree opclass so the recommended ---! functional index `CREATE INDEX ON t (eql_v3.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.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.ore_block_256_operator_class DEFAULT FOR TYPE eql_v3.ore_block_256 USING btree FAMILY eql_v3.ore_block_256_operator_family AS - OPERATOR 1 <, - OPERATOR 2 <=, - OPERATOR 3 =, - OPERATOR 4 >=, - OPERATOR 5 >, - FUNCTION 1 eql_v3.compare_ore_block_256_terms(a eql_v3.ore_block_256, b eql_v3.ore_block_256); - ---! @file v3/sem/ore_cllw/operators.sql ---! @brief Comparison operators on the eql_v3.ore_cllw composite type. ---! ---! Each backing function reduces to a single SELECT over ---! eql_v3.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.compare_ore_cllw_term - ---! @brief Equality backing function for eql_v3.ore_cllw. ---! @internal ---! ---! @param a eql_v3.ore_cllw Left operand ---! @param b eql_v3.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are equal ---! ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw_eq(a eql_v3.ore_cllw, b eql_v3.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_cllw_term(a, b) = 0 -$$; - ---! @brief Not-equal backing function for eql_v3.ore_cllw. ---! @internal ---! ---! @param a eql_v3.ore_cllw Left operand ---! @param b eql_v3.ore_cllw Right operand ---! @return boolean True if the CLLW ORE terms are not equal ---! ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw_neq(a eql_v3.ore_cllw, b eql_v3.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_cllw_term(a, b) <> 0 -$$; - ---! @brief Less-than backing function for eql_v3.ore_cllw. ---! @internal ---! ---! @param a eql_v3.ore_cllw Left operand ---! @param b eql_v3.ore_cllw Right operand ---! @return boolean True if the left operand is less than the right operand ---! ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw_lt(a eql_v3.ore_cllw, b eql_v3.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_cllw_term(a, b) = -1 -$$; - ---! @brief Less-than-or-equal backing function for eql_v3.ore_cllw. ---! @internal ---! ---! @param a eql_v3.ore_cllw Left operand ---! @param b eql_v3.ore_cllw Right operand ---! @return boolean True if the left operand is less than or equal to the right operand ---! ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw_lte(a eql_v3.ore_cllw, b eql_v3.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_cllw_term(a, b) <> 1 -$$; - ---! @brief Greater-than backing function for eql_v3.ore_cllw. ---! @internal ---! ---! @param a eql_v3.ore_cllw Left operand ---! @param b eql_v3.ore_cllw Right operand ---! @return boolean True if the left operand is greater than the right operand ---! ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw_gt(a eql_v3.ore_cllw, b eql_v3.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_cllw_term(a, b) = 1 -$$; - ---! @brief Greater-than-or-equal backing function for eql_v3.ore_cllw. ---! @internal ---! ---! @param a eql_v3.ore_cllw Left operand ---! @param b eql_v3.ore_cllw Right operand ---! @return boolean True if the left operand is greater than or equal to the right operand ---! ---! @see eql_v3.compare_ore_cllw_term -CREATE FUNCTION eql_v3.ore_cllw_gte(a eql_v3.ore_cllw, b eql_v3.ore_cllw) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3.compare_ore_cllw_term(a, b) <> -1 -$$; - - -CREATE OPERATOR = ( - FUNCTION = eql_v3.ore_cllw_eq, - LEFTARG = eql_v3.ore_cllw, - RIGHTARG = eql_v3.ore_cllw, - COMMUTATOR = =, - NEGATOR = <>, - RESTRICT = eqsel, - JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.ore_cllw_neq, - LEFTARG = eql_v3.ore_cllw, - RIGHTARG = eql_v3.ore_cllw, - COMMUTATOR = <>, - NEGATOR = =, - RESTRICT = neqsel, - JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.ore_cllw_lt, - LEFTARG = eql_v3.ore_cllw, - RIGHTARG = eql_v3.ore_cllw, - COMMUTATOR = >, - NEGATOR = >=, - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.ore_cllw_lte, - LEFTARG = eql_v3.ore_cllw, - RIGHTARG = eql_v3.ore_cllw, - COMMUTATOR = >=, - NEGATOR = >, - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.ore_cllw_gt, - LEFTARG = eql_v3.ore_cllw, - RIGHTARG = eql_v3.ore_cllw, - COMMUTATOR = <, - NEGATOR = <=, - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.ore_cllw_gte, - LEFTARG = eql_v3.ore_cllw, - RIGHTARG = eql_v3.ore_cllw, - COMMUTATOR = <=, - NEGATOR = <, - RESTRICT = scalargesel, - JOIN = scalargejoinsel -); - ---! @file v3/sem/ore_cllw/operator_class.sql ---! @brief Btree operator class on the eql_v3.ore_cllw composite type. ---! ---! DEFAULT FOR TYPE so a functional btree index on eql_v3.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.compare_ore_cllw_term - -CREATE OPERATOR FAMILY eql_v3.ore_cllw_ops USING btree; - -CREATE OPERATOR CLASS eql_v3.ore_cllw_ops - DEFAULT FOR TYPE eql_v3.ore_cllw - USING btree FAMILY eql_v3.ore_cllw_ops AS - OPERATOR 1 < (eql_v3.ore_cllw, eql_v3.ore_cllw), - OPERATOR 2 <= (eql_v3.ore_cllw, eql_v3.ore_cllw), - OPERATOR 3 = (eql_v3.ore_cllw, eql_v3.ore_cllw), - OPERATOR 4 >= (eql_v3.ore_cllw, eql_v3.ore_cllw), - OPERATOR 5 > (eql_v3.ore_cllw, eql_v3.ore_cllw), - FUNCTION 1 eql_v3.compare_ore_cllw_term(eql_v3.ore_cllw, eql_v3.ore_cllw); - ---! @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.jsonb_entry_min_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry -) -RETURNS eql_v3.jsonb_entry + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for public.timestamp_ord. + +--! @brief State function for min on public.timestamp_ord. +--! @param state public.timestamp_ord +--! @param value public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord, value public.timestamp_ord) +RETURNS public.timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ -DECLARE - value_ore eql_v3.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3.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 + IF value < state 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.jsonb_entry_min_sfunc, - stype = eql_v3.jsonb_entry, - combinefunc = eql_v3.jsonb_entry_min_sfunc, +--! @brief min aggregate for public.timestamp_ord. +--! @param input public.timestamp_ord +--! @return public.timestamp_ord +CREATE AGGREGATE eql_v3.min(public.timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord, + combinefunc = eql_v3_internal.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.jsonb_entry_max_sfunc( - state eql_v3.jsonb_entry, - value eql_v3.jsonb_entry -) -RETURNS eql_v3.jsonb_entry +--! @brief State function for max on public.timestamp_ord. +--! @param state public.timestamp_ord +--! @param value public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord, value public.timestamp_ord) +RETURNS public.timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ -DECLARE - value_ore eql_v3.ore_cllw := eql_v3.ore_cllw(value); - state_ore eql_v3.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 + IF value > state 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.jsonb_entry_max_sfunc, - stype = eql_v3.jsonb_entry, - combinefunc = eql_v3.jsonb_entry_max_sfunc, +--! @brief max aggregate for public.timestamp_ord. +--! @param input public.timestamp_ord +--! @return public.timestamp_ord +CREATE AGGREGATE eql_v3.max(public.timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/jsonb/operators.sql ---! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for public.timestamp_ord_ore. ------------------------------------------------------------------------------- --- -> field accessor (returns jsonb_entry) ------------------------------------------------------------------------------- +--! @brief Index extractor for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.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 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 -$$; +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, - RIGHTARG=text -); +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.timestamp_ord_ore) $$; ---! @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.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 -$$; +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) = eql_v3.ord_term(b) $$; -CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=eql_v3.json, - RIGHTARG=integer -); +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.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::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.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::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.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::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.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::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector text +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ore, selector text) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector integer +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ore, selector integer) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; ------------------------------------------------------------------------------- --- ->> field accessor (alias of -> coerced to text) ------------------------------------------------------------------------------- +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @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 -$$; +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, - RIGHTARG=text -); +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. ---! @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 -$$; +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for public.timestamp_ord_ore. -CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=eql_v3.json, - RIGHTARG=integer +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); ------------------------------------------------------------------------------- --- @> 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.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); ---! @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.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_query +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); ---! @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.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.jsonb_entry +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); ------------------------------------------------------------------------------- --- <@ contained-by (reverse of @>) ------------------------------------------------------------------------------- +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.json, - RIGHTARG=eql_v3.json +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); ---! @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.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_query, - RIGHTARG=eql_v3.json +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); ---! @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.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); -CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.jsonb_entry, - RIGHTARG=eql_v3.json +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); ------------------------------------------------------------------------------- --- jsonb_entry comparisons ------------------------------------------------------------------------------- +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). ---! @internal ---! @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.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = =, - NEGATOR = <>, - RESTRICT = eqsel, - JOIN = eqjoinsel +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); ---! @brief Inequality on jsonb_entry via eq_term. ---! @internal ---! @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.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <>, - NEGATOR = =, - RESTRICT = neqsel, - JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore ); ---! @brief Less-than on jsonb_entry via ore_cllw. ---! @internal ---! @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_internal.contains, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = >, - NEGATOR = >=, - RESTRICT = scalarltsel, - JOIN = scalarltjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore ); ---! @brief Less-than-or-equal on jsonb_entry via ore_cllw. ---! @internal ---! @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_internal.contained_by, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = >=, - NEGATOR = >, - RESTRICT = scalarlesel, - JOIN = scalarlejoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb ); ---! @brief Greater-than on jsonb_entry via ore_cllw. ---! @internal ---! @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_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <, - NEGATOR = <=, - RESTRICT = scalargtsel, - JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text ); ---! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. ---! @internal ---! @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_internal."->", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.jsonb_entry, - RIGHTARG = eql_v3.jsonb_entry, - COMMUTATOR = <=, - NEGATOR = <, - RESTRICT = scalargesel, - JOIN = scalargejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore ); ---! @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. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', '?'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); -CREATE OPERATOR ? ( - FUNCTION = eql_v3.jsonb_blocked_exists, - LEFTARG = eql_v3.json, - RIGHTARG = text +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore ); ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); CREATE OPERATOR ?| ( - FUNCTION = eql_v3.jsonb_blocked_exists_any, - LEFTARG = eql_v3.json, - RIGHTARG = text[] + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); -END; -$$ LANGUAGE plpgsql; - CREATE OPERATOR ?& ( - FUNCTION = eql_v3.jsonb_blocked_exists_all, - LEFTARG = eql_v3.json, - RIGHTARG = text[] + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); -END; -$$ LANGUAGE plpgsql; - CREATE OPERATOR @? ( - FUNCTION = eql_v3.jsonb_blocked_jsonpath_exists, - LEFTARG = eql_v3.json, - RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); -END; -$$ LANGUAGE plpgsql; - CREATE OPERATOR @@ ( - FUNCTION = eql_v3.jsonb_blocked_jsonpath_match, - LEFTARG = eql_v3.json, - RIGHTARG = jsonpath + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); -END; -$$ LANGUAGE plpgsql; - CREATE OPERATOR #> ( - FUNCTION = eql_v3.jsonb_blocked_path_extract, - LEFTARG = eql_v3.json, - RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); -END; -$$ LANGUAGE plpgsql; - CREATE OPERATOR #>> ( - FUNCTION = eql_v3.jsonb_blocked_path_extract_text, - LEFTARG = eql_v3.json, - RIGHTARG = text[] + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; - CREATE OPERATOR - ( - FUNCTION = eql_v3.jsonb_blocked_delete_text, - LEFTARG = eql_v3.json, - RIGHTARG = text + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, 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.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.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); CREATE OPERATOR - ( - FUNCTION = eql_v3.jsonb_blocked_delete_int, - LEFTARG = eql_v3.json, - RIGHTARG = integer + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] ); ---! @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.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.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); -CREATE OPERATOR - ( - FUNCTION = eql_v3.jsonb_blocked_delete_array, - LEFTARG = eql_v3.json, - RIGHTARG = text[] +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore ); ---! @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.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.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); -CREATE OPERATOR #- ( - FUNCTION = eql_v3.jsonb_blocked_delete_path, - LEFTARG = eql_v3.json, - RIGHTARG = text[] +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore ); +-- AUTOMATICALLY GENERATED FILE. ---! @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.jsonb_blocked_concat(a eql_v3.json, b jsonb) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for public.timestamp_ord_ore. + +--! @brief State function for min on public.timestamp_ord_ore. +--! @param state public.timestamp_ord_ore +--! @param value public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord_ore, value public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); + IF value < state THEN + RETURN value; + END IF; + RETURN state; END; -$$ LANGUAGE plpgsql; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3.jsonb_blocked_concat, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb +--! @brief min aggregate for public.timestamp_ord_ore. +--! @param input public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(public.timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); ---! @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.jsonb_blocked_concat_rhs(a jsonb, b eql_v3.json) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE +--! @brief State function for max on public.timestamp_ord_ore. +--! @param state public.timestamp_ord_ore +--! @param value public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord_ore, value public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); + IF value > state THEN + RETURN value; + END IF; + RETURN state; END; -$$ LANGUAGE plpgsql; +$$; + +--! @brief max aggregate for public.timestamp_ord_ore. +--! @param input public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(public.timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_query_functions.sql +--! @brief Functions for public.timestamp_ord_ore_query. + +--! @brief Index extractor for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3.jsonb_blocked_concat_rhs, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ------------------------------------------------------------------------------- --- Root-document comparison blockers. ------------------------------------------------------------------------------- +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief 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.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.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief 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.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.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); -END; -$$ LANGUAGE plpgsql; +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json -); +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR = ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb -); +--! @file encrypted_domain/timestamp/timestamp_ord_ore_query_operators.sql +--! @brief Operators for public.timestamp_ord_ore_query. CREATE OPERATOR = ( - FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_json, - LEFTARG = eql_v3.json, - RIGHTARG = eql_v3.json + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb +--! @file encrypted_domain/timestamp/timestamp_ord_query_functions.sql +--! @brief Functions for public.timestamp_ord_query. + +--! @brief Index extractor for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_query_operators.sql +--! @brief Operators for public.timestamp_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); ------------------------------------------------------------------------------- --- Mixed jsonb containment blockers. ------------------------------------------------------------------------------- +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @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.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.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); -END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.jsonb_blocked_contains_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.jsonb_blocked_contains_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.jsonb_blocked_contained_json_jsonb, - LEFTARG = eql_v3.json, - RIGHTARG = jsonb +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.jsonb_blocked_contained_jsonb_json, - LEFTARG = jsonb, - RIGHTARG = eql_v3.json +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --! @file pin_search_path_v3.sql --! @brief Post-install: pin search_path on every eql_v3.* function. @@ -29680,14 +43230,15 @@ CREATE OPERATOR <@ ( --! 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` schema and applies a fixed ---! `search_path` via `ALTER FUNCTION ... SET search_path = ...`, satisfying ---! Supabase splinter's `function_search_path_mutable` lint. +--! 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, ---! hmac_256, bloom_filter over jsonb) and the encrypted-domain family ---! (recognised structurally) are deliberately left unpinned. +--! ope_cllw, hmac_256, bloom_filter over jsonb) and the +--! encrypted-domain family (recognised structurally, including public +--! user-column domains) are deliberately left unpinned. --! @see tasks/test/splinter.sh --! @see tasks/build.sh @@ -29712,7 +43263,7 @@ BEGIN 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 = 'eql_v3' + 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', @@ -29725,6 +43276,12 @@ BEGIN 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) @@ -29737,7 +43294,7 @@ BEGIN SELECT p.oid FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = 'eql_v3' + 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 @@ -29745,7 +43302,9 @@ BEGIN ) 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. + -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column + -- domains live in public; implementation-only domains live in EQL-owned + -- schemas. AND NOT ( p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l WHERE l.lanname = 'sql') @@ -29757,7 +43316,10 @@ BEGIN JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace WHERE dt.typtype = 'd' AND dt.typbasetype = jsonb_oid - AND dn.nspname = 'eql_v3' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) ) ) -- Comment-marker fallback for hand-written inline-critical extension diff --git a/packages/stack/__tests__/helpers/eql-v3.ts b/packages/stack/__tests__/helpers/eql-v3.ts index ab9e4f57..4ccb34ef 100644 --- a/packages/stack/__tests__/helpers/eql-v3.ts +++ b/packages/stack/__tests__/helpers/eql-v3.ts @@ -14,13 +14,13 @@ const eqlV3SqlPath = resolve( // The sentinel must be a type that exists ONLY in the currently vendored // bundle, so a database still carrying an older EQL v3 install is detected as // stale and reinstalled (the bundle's leading DROP SCHEMA … CASCADE replaces -// the old install wholesale). eql_v3.timestamp is new in the current bundle +// the old install wholesale). public.timestamp is new in the current bundle // (the timestamptz → timestamp rename, encrypt-query-language@2e64ca73); the -// previous sentinel, eql_v3.text_search, exists in both generations and would +// previous sentinel, public.text_search, exists in both generations and would // leave a stale install in place. async function hasCurrentEqlV3(sql: postgres.Sql): Promise { const [row] = await sql<{ installed: boolean }[]>` - SELECT to_regtype('eql_v3.timestamp') IS NOT NULL AS installed + SELECT to_regtype('public.timestamp') IS NOT NULL AS installed ` return row?.installed ?? false } @@ -49,7 +49,7 @@ export async function installEqlV3IfNeeded(sql: postgres.Sql): Promise { await reserved.unsafe(eqlV3Sql) if (!(await hasCurrentEqlV3(reserved))) { - throw new Error('EQL v3 installation did not create eql_v3.timestamp') + throw new Error('EQL v3 installation did not create public.timestamp') } } finally { await reserved`SELECT pg_advisory_unlock(${EQL_V3_ADVISORY_LOCK_ID})` diff --git a/packages/stack/__tests__/live-coverage-guard.test.ts b/packages/stack/__tests__/live-coverage-guard.test.ts new file mode 100644 index 00000000..aed0ad6d --- /dev/null +++ b/packages/stack/__tests__/live-coverage-guard.test.ts @@ -0,0 +1,95 @@ +/** + * Live-coverage guard — a meta-test that is DELIBERATELY NOT wrapped in any + * `describeLive*` gate, so it always runs (in CI and locally). + * + * ## Why this exists + * Every live (network/DB-touching) suite gates itself on the flags exported by + * `./helpers/live-gate`: + * - `LIVE_CIPHERSTASH_ENABLED` — all four CS_* creds present + * - `LIVE_EQL_V3_PG_ENABLED` — the above AND `DATABASE_URL` present + * When a flag is false the suite becomes `describe.skip`. That is correct + * locally, but in CI it means a rotated/cleared secret (or a missing + * `DATABASE_URL`) makes the ENTIRE live matrix silently skip while the job + * still goes GREEN — zero live coverage, no signal. + * + * The `require-cs-secrets` CI action catches missing CS_* secrets, but it + * (a) does NOT check `DATABASE_URL` (the pg-gate input), and (b) only proves + * the ENV is set on the runner, not that the suites actually consumed it and + * ran. This meta-test closes both gaps by asserting the very flags the live + * suites branch on. Because the suites gate on these EXACT flags, proving the + * flags are `true` in CI transitively guarantees the live suites — and their + * `beforeAll` setup — execute rather than skip. A silent whole-matrix skip + * becomes a loud, single-line failure. + * + * ## CI-only enforcement + * Enforcement is scoped to `process.env.CI` (GitHub Actions always sets + * `CI=true`). Locally, with no creds, this test is a no-op so ordinary dev + * runs still pass. See `.github/workflows/tests.yml` — the `run-tests` job runs + * `pnpm run test` on a runner where GitHub injects `CI=true`, and the CS_* + * creds + `DATABASE_URL` are written into `packages/stack/.env` (loaded here + * via `dotenv/config`, exactly as the live suites load them). + * + * ## Import order matters + * `import 'dotenv/config'` MUST come first: in CI the creds live in + * `packages/stack/.env`, and `live-gate` evaluates the flags at module-load + * time. Loading dotenv before importing the gate mirrors what every live suite + * does and ensures the flags reflect the real environment. + * + * ## Layer 2 (execution census) — intentionally NOT added + * A stronger check would assert each critical live file executed its expected + * number of tests with zero skips (e.g. via `--reporter=json` + a script, or a + * vitest `onFinished` hook). It is omitted on purpose: + * - The live suites gate on the SAME flags asserted here, so this Layer-1 + * check already guarantees they run — a census would only re-detect the + * same "did the matrix run" failure it is meant to catch. + * - A per-file count census needs hardcoded expected totals that drift every + * time a domain/case is added, turning a safety net into maintenance debt. + * - It would add an extra CI step / reporter wiring for marginal signal. + * If a future regression is ever a *partial* skip (individual `it.skip` inside + * an enabled suite — a different failure mode than the silent whole-matrix skip + * this guards), extend here with a `--reporter=json` post-run script asserting + * `numPendingTests === 0` for the critical files, rather than hardcoding counts. + */ +import 'dotenv/config' +import { describe, expect, it } from 'vitest' +import { + LIVE_CIPHERSTASH_ENABLED, + LIVE_EQL_V3_PG_ENABLED, +} from './helpers/live-gate' + +// GitHub Actions always sets CI=true; treat any truthy CI as "must run live". +const IN_CI = Boolean(process.env.CI) + +describe('live-coverage guard', () => { + it.runIf(IN_CI)( + 'CI must have CipherStash creds so the live suites do not silently skip', + () => { + expect( + LIVE_CIPHERSTASH_ENABLED, + 'CI must run the live suites — CS_* creds missing (CS_WORKSPACE_CRN / ' + + 'CS_CLIENT_ID / CS_CLIENT_KEY / CS_CLIENT_ACCESS_KEY) → every ' + + '`describeLive` suite becomes describe.skip and the live matrix ' + + 'silently skips while CI stays green.', + ).toBe(true) + }, + ) + + it.runIf(IN_CI)( + 'CI must have DATABASE_URL so the live pg suites do not silently skip', + () => { + expect( + LIVE_EQL_V3_PG_ENABLED, + 'CI must run the live Postgres suites — `LIVE_EQL_V3_PG_ENABLED` is ' + + 'false. This needs the CS_* creds AND a `DATABASE_URL`; a missing ' + + 'DATABASE_URL is the hole the require-cs-secrets action does not ' + + 'cover, and makes every `describeLivePg` suite silently skip.', + ).toBe(true) + }, + ) + + // Local dev with no creds: nothing to assert. Keep at least one always-run + // assertion so the file is never reported as fully empty/pending. + it('is always collected (guard file runs outside every live gate)', () => { + expect(typeof IN_CI).toBe('boolean') + }) +}) diff --git a/packages/stack/__tests__/schema-v3-client.test.ts b/packages/stack/__tests__/schema-v3-client.test.ts index 5d47b409..ef580e1e 100644 --- a/packages/stack/__tests__/schema-v3-client.test.ts +++ b/packages/stack/__tests__/schema-v3-client.test.ts @@ -9,11 +9,11 @@ import { describeLive, LIVE_CIPHERSTASH_ENABLED } from './helpers/live-gate' const users = encryptedTable('schema_v3_client_users', { email: types.TextSearch('email'), - age: types.Int4Ord('age'), + age: types.IntegerOrd('age'), nickname: types.TextEq('nickname'), body: types.TextMatch('body'), notes: types.Text('notes'), - active: types.Bool('active'), + 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. diff --git a/packages/stack/__tests__/schema-v3-pg.test.ts b/packages/stack/__tests__/schema-v3-pg.test.ts index 42dbe2d0..8ee6dfc5 100644 --- a/packages/stack/__tests__/schema-v3-pg.test.ts +++ b/packages/stack/__tests__/schema-v3-pg.test.ts @@ -1,6 +1,6 @@ import 'dotenv/config' import postgres from 'postgres' -import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest' +import { afterAll, beforeAll, beforeEach, expect, it } from 'vitest' import type { EncryptionClient } from '@/encryption' import { encryptedTable, types } from '@/eql/v3' import { Encryption } from '@/index' @@ -19,9 +19,9 @@ const table = encryptedTable('protect_ci_v3_text_search', { }) const typedTable = encryptedTable('protect_ci_v3_typed_domains', { - age: types.Int4Ord('age'), + age: types.IntegerOrd('age'), nickname: types.TextEq('nickname'), - active: types.Bool('active'), + active: types.Boolean('active'), }) const TEST_RUN_ID = `test-run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` @@ -45,16 +45,18 @@ async function encryptValue(value: string): Promise { ) as EncryptionPayload } -async function encryptQueryTerm( - value: string, - queryType?: 'equality' | 'freeTextSearch' | 'orderAndRange', +// A query operand under EQL v3 is a FULL encrypted payload — the same thing +// `client.encrypt` produces for storage — NOT an `encryptQuery` term (protect-ffi +// 0.28 has no v3 scalar query wire shape; `encryptQuery` throws +// EQL_V3_QUERY_UNSUPPORTED). Compare it to a column with the public two-arg +// `eql_v3.*(col, operand::jsonb)` functions; the operand carries every index +// term, so which SQL function you call selects which term is compared. +async function encryptOperand( + value: unknown, + opts: Parameters[1], ): Promise { return unwrapResult( - await protectClient.encryptQuery(value, { - table, - column: table.email, - queryType, - }), + await protectClient.encrypt(value as never, opts), ) as EncryptionPayload } @@ -63,7 +65,7 @@ async function insertRow(label: string, email: string): Promise { 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}) + VALUES (${sql.json(encrypted)}::public.text_search, ${label}, ${TEST_RUN_ID}) RETURNING id ` @@ -93,12 +95,26 @@ beforeAll(async () => { if (!LIVE_EQL_V3_PG_ENABLED) return await installEqlV3IfNeeded(sql) - protectClient = await Encryption({ schemas: [table, typedTable] }) + // `eqlVersion: 3` is required for v3 concrete-type schemas: protect-ffi's + // newClient defaults to v2, and a v2-mode client cannot encrypt these columns + // (it throws "Cannot convert undefined or null to object"). EncryptionV3 sets + // this automatically; the base `Encryption` factory does not, so pass it here. + protectClient = await Encryption({ + schemas: [table, typedTable], + config: { eqlVersion: 3 }, + }) + + // DROP first: these tables are created with IF NOT EXISTS and cleaned up by + // row DELETE only, so one left by an earlier local run keeps its OLD column + // domain types across the `eql_v3.* -> public.*` rename — silently testing a + // stale schema. Harmless in CI (fresh Postgres); reliable local reruns. + await sql`DROP TABLE IF EXISTS protect_ci_v3_text_search` + await sql`DROP TABLE IF EXISTS protect_ci_v3_typed_domains` 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, + email public.text_search NOT NULL, label TEXT NOT NULL, test_run_id TEXT NOT NULL ) @@ -107,9 +123,9 @@ beforeAll(async () => { await 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, + age public.integer_ord NOT NULL, + nickname public.text_eq NOT NULL, + active public.boolean NOT NULL, test_run_id TEXT NOT NULL ) ` @@ -143,7 +159,7 @@ afterAll(async () => { }, 30000) describeLivePg('eql_v3 text_search postgres integration', () => { - it('round-trips an encrypted value through an eql_v3.text_search column', async () => { + it('round-trips an encrypted value through an public.text_search column', async () => { const id = await insertRow('roundtrip', 'roundtrip@example.com') const [row] = await sql` @@ -156,15 +172,18 @@ describeLivePg('eql_v3 text_search postgres integration', () => { await expect(decryptRow(row)).resolves.toBe('roundtrip@example.com') }, 30000) - it('queries equality terms with eql_v3.eq_term and eql_v3.hmac_256', async () => { + it('queries equality with eql_v3.eq and a full operand', async () => { const ids = await seedRows() - const equalityTerm = await encryptQueryTerm('grace@example.com', 'equality') + const operand = await encryptOperand('grace@example.com', { + table, + column: table.email, + }) const rows = await sql` 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.hmac_256(${sql.json(equalityTerm)}::jsonb) + AND eql_v3.eq(email, ${sql.json(operand)}::jsonb) ORDER BY id ` @@ -172,38 +191,91 @@ describeLivePg('eql_v3 text_search postgres integration', () => { await expect(decryptRow(rows[0])).resolves.toBe('grace@example.com') }, 30000) - it('queries free-text terms with eql_v3.match_term and eql_v3.bloom_filter', async () => { + it('queries free-text with eql_v3.contains and a full operand', async () => { await seedRows() - const matchTerm = await encryptQueryTerm('example.com', 'freeTextSearch') + const operand = await encryptOperand('example.com', { + table, + column: table.email, + }) const rows = await sql` 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.bloom_filter(${sql.json(matchTerm)}::jsonb) + AND eql_v3.contains(email, ${sql.json(operand)}::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.ore_block_256', async () => { + it('queries range with eql_v3.gte/lte and full operands', async () => { await seedRows() - const lower = await encryptQueryTerm('grace@example.com', 'orderAndRange') - const upper = await encryptQueryTerm('zora@example.org', 'orderAndRange') + const lower = await encryptOperand('grace@example.com', { + table, + column: table.email, + }) + const upper = await encryptOperand('zora@example.org', { + table, + column: table.email, + }) const rows = await sql` 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.ore_block_256(${sql.json(lower)}::jsonb) - AND eql_v3.ord_term(email) <= eql_v3.ore_block_256(${sql.json(upper)}::jsonb) - ORDER BY eql_v3.ord_term(email) + AND eql_v3.gte(email, ${sql.json(lower)}::jsonb) + AND eql_v3.lte(email, ${sql.json(upper)}::jsonb) + ORDER BY label ` + // Assert range MEMBERSHIP deterministically by ordering on the plaintext + // `label`. The range predicate above (eql_v3.gte/lte) already proves the ORE + // comparison is lexically correct: it selects grace+zora and excludes + // ada/alan. + // + // NB: we deliberately do NOT order by `eql_v3.ord_term(email)` (nor by the + // `email` column, nor `email USING <`). None of those yield ORE order on a + // non-superuser Postgres: `ord_term` returns the composite + // `eql_v3_internal.ore_block_256`, whose ORE-aware btree opclass is + // superuser-gated and skipped on managed installs, so `ORDER BY ord_term` + // silently falls back to PostgreSQL's built-in record comparison (raw-byte + // order, not ORE). See docs/eql-v3-ord-term-ordering-defect.md. expect(rows.map((row) => row.label)).toEqual(['grace', 'zora']) }, 30000) + it('proves ORE total order via pairwise eql_v3.lt (ord_term ORDER BY is NOT ORE order)', async () => { + // The ORE comparison operators are ORE-correct even where `ORDER BY + // ord_term(col)` is not (see docs/eql-v3-ord-term-ordering-defect.md). + // Reconstruct the total order purely from boolean `eql_v3.lt` predicates: a + // self cross-join gives, for each ordered pair, whether x < y under ORE; the + // count of rows a label is strictly-less-than is its ascending rank. + await seedRows() + + const pairs = await sql<{ a: string; b: string; lt: boolean }[]>` + SELECT x.label AS a, y.label AS b, eql_v3.lt(x.email, y.email) AS lt + FROM protect_ci_v3_text_search x + CROSS JOIN protect_ci_v3_text_search y + WHERE x.test_run_id = ${TEST_RUN_ID} + AND y.test_run_id = ${TEST_RUN_ID} + AND x.label <> y.label + ` + + const labels = ['ada', 'grace', 'alan', 'zora'] + const lessThanCount = new Map(labels.map((l) => [l, 0])) + for (const pair of pairs) { + if (pair.lt) lessThanCount.set(pair.a, (lessThanCount.get(pair.a) ?? 0) + 1) + } + + const ascending = [...lessThanCount.entries()] + .sort(([, aRank], [, bRank]) => bRank - aRank) + .map(([label]) => label) + + // Lexical/ORE order of the seeded emails: + // ada@example.com < alan@example.net < grace@example.com < zora@example.org + expect(ascending).toEqual(['ada', 'alan', '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 @@ -242,14 +314,21 @@ describeLivePg('eql_v3 text_search postgres integration', () => { ) }, 30000) - it('rejects query-only payloads cast as eql_v3.text_search values', async () => { - const equalityTerm = await encryptQueryTerm('ada@example.com', 'equality') + it('rejects a ciphertext-less payload cast as a public.text_search value', async () => { + // A full operand with its ciphertext (`c`) removed mimics a query-only + // payload: index terms present, no stored value. The domain CHECK must + // reject it, so it can never masquerade as a stored ciphertext. + const full = (await encryptOperand('ada@example.com', { + table, + column: table.email, + })) as Record + const { c: _ciphertext, ...ciphertextLess } = full await expect( sql` INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) VALUES ( - ${sql.json(equalityTerm)}::eql_v3.text_search, + ${sql.json(ciphertextLess as EncryptionPayload)}::public.text_search, 'query-only', ${TEST_RUN_ID} ) @@ -280,37 +359,35 @@ describeLivePg('eql_v3 text_search postgres integration', () => { 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, + ${sql.json(age as postgres.JSONValue)}::public.integer_ord, + ${sql.json(nickname as postgres.JSONValue)}::public.text_eq, + ${sql.json(active as postgres.JSONValue)}::public.boolean, ${TEST_RUN_ID} ) RETURNING id ` - const ageTerm = unwrapResult( - await protectClient.encryptQuery(30, { - table: typedTable, - column: typedTable.age, - queryType: 'orderAndRange', - }), - ) as postgres.JSONValue + const ageTerm = await encryptOperand(30, { + table: typedTable, + column: typedTable.age, + }) 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) + AND eql_v3.gte(age, ${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 int4_ord column', async () => { + // Correctness proof for equality-via-ORE on an `integer_ord` column. The + // `integer_ord` domain carries only an `ore` (`ob`) index and no `hm`, so + // `eql_v3.eq(integer_ord, operand)` internally compares `ord_term` — i.e. + // equality answered through ORE. This proves that resolves the exact row + // against real Postgres with a full operand (no `encryptQuery` term). + it('selects the exact row for equality-via-ORE on an integer_ord column', async () => { async function insertAge(age: number): Promise { const ageCt = unwrapResult( await protectClient.encrypt(age, { @@ -333,9 +410,9 @@ describeLivePg('eql_v3 text_search postgres integration', () => { 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.int4_ord, - ${sql.json(nick)}::eql_v3.text_eq, - ${sql.json(act)}::eql_v3.bool, + ${sql.json(ageCt)}::public.integer_ord, + ${sql.json(nick)}::public.text_eq, + ${sql.json(act)}::public.boolean, ${TEST_RUN_ID} ) RETURNING id @@ -349,21 +426,18 @@ describeLivePg('eql_v3 text_search postgres integration', () => { 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 protectClient.encryptQuery(37, { - table: typedTable, - column: typedTable.age, - queryType: 'equality', - }), - ) as postgres.JSONValue + // Full operand for 37; `eql_v3.eq(integer_ord, operand)` compares `ord_term`, + // so this is equality answered via ORE. + const equalityTerm = await encryptOperand(37, { + table: typedTable, + column: typedTable.age, + }) 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.ore_block_256(${sql.json(equalityTerm)}::jsonb) + AND eql_v3.eq(age, ${sql.json(equalityTerm)}::jsonb) ORDER BY id ` // Exactly the age=37 row — not the 30 or 42 rows. @@ -372,18 +446,15 @@ describeLivePg('eql_v3 text_search postgres integration', () => { expect(matched.map((row) => row.id)).not.toContain(ids.fortyTwo) // A non-matching value selects nothing. - const missTerm = unwrapResult( - await protectClient.encryptQuery(99, { - table: typedTable, - column: typedTable.age, - queryType: 'equality', - }), - ) as postgres.JSONValue + const missTerm = await encryptOperand(99, { + table: typedTable, + column: typedTable.age, + }) 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.ore_block_256(${sql.json(missTerm)}::jsonb) + AND eql_v3.eq(age, ${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 index f3eabee0..8eac1035 100644 --- a/packages/stack/__tests__/schema-v3.test-d.ts +++ b/packages/stack/__tests__/schema-v3.test-d.ts @@ -21,6 +21,11 @@ describe('eql_v3 schema type inference', () => { expectTypeOf(col).toEqualTypeOf() }) + it('does not expose bigint factories until native bigint round-tripping lands', () => { + // @ts-expect-error - bigint v3 domains are intentionally not public yet + types.Bigint('large') + }) + it('encryptedTable exposes column builders as typed properties', () => { const users = encryptedTable('users', { email: types.TextSearch('email'), @@ -56,10 +61,10 @@ describe('eql_v3 schema type inference', () => { it('InferPlaintext maps v3 concrete domains to plaintext TypeScript types', () => { const metrics = encryptedTable('metrics', { name: types.Text('name'), - age: types.Int4('age'), - active: types.Bool('active'), + age: types.Integer('age'), + active: types.Boolean('active'), createdAt: types.Timestamp('created_at'), - score: types.Float8('score'), + score: types.Double('score'), }) type Plaintext = InferPlaintext @@ -75,12 +80,12 @@ describe('eql_v3 schema type inference', () => { it('v3 domain classes remain nominal by literal domain definition', () => { const date = types.Date('created_on') - const bool = types.Bool('active') + const boolean = types.Boolean('active') - expectTypeOf(date).not.toEqualTypeOf() + expectTypeOf(date).not.toEqualTypeOf() - // @ts-expect-error - storage-only bool is not assignable to storage-only date - const invalid: typeof date = bool + // @ts-expect-error - storage-only boolean is not assignable to storage-only date + const invalid: typeof date = boolean void invalid }) }) @@ -102,6 +107,20 @@ describe('eql_v3 client integration (type-level acceptance)', () => { }) }) + it('encrypt and encryptQuery accept bigint plaintext (native round-tripping landed in protect-ffi 0.28)', () => { + const client = {} as EncryptionClient + + expectTypeOf(client.encrypt).toBeCallableWith(1n, { + table: v3users, + column: v3users.email, + }) + + expectTypeOf(client.encryptQuery).toBeCallableWith(1n, { + table: v3users, + column: v3users.email, + }) + }) + it('encryptQuery accepts a v3 table + column', () => { const client = {} as EncryptionClient expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { @@ -194,7 +213,7 @@ describe('eql_v3 client integration (type-level acceptance)', () => { it('encryptQuery rejects storage-only v3 columns at compile time', () => { const users = encryptedTable('users', { email: types.Text('email'), - active: types.Bool('active'), + active: types.Boolean('active'), }) const client = {} as EncryptionClient @@ -206,7 +225,7 @@ describe('eql_v3 client integration (type-level acceptance)', () => { client.encryptQuery(true, { table: users, - // @ts-expect-error - storage-only v3 bool column is not queryable + // @ts-expect-error - storage-only v3 boolean column is not queryable column: users.active, }) }) @@ -216,7 +235,7 @@ 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.Bool('active'), + active: types.Boolean('active'), }) const client = {} as EncryptionClient diff --git a/packages/stack/__tests__/schema-v3.test.ts b/packages/stack/__tests__/schema-v3.test.ts index 746dc6a8..fcb1db8f 100644 --- a/packages/stack/__tests__/schema-v3.test.ts +++ b/packages/stack/__tests__/schema-v3.test.ts @@ -156,6 +156,32 @@ describe('eql_v3 text_match column', () => { }) }) +describe('eql_v3 concrete type names', () => { + it('preserves public factory names while exposing concrete Postgres domain names', () => { + expect(types.Integer('n').getEqlType()).toBe('public.integer') + expect(types.IntegerEq('n').getEqlType()).toBe('public.integer_eq') + expect(types.IntegerOrdOre('n').getEqlType()).toBe('public.integer_ord_ore') + expect(types.IntegerOrd('n').getEqlType()).toBe('public.integer_ord') + + expect(types.Smallint('n').getEqlType()).toBe('public.smallint') + expect(types.SmallintEq('n').getEqlType()).toBe('public.smallint_eq') + expect(types.SmallintOrdOre('n').getEqlType()).toBe( + 'public.smallint_ord_ore', + ) + expect(types.SmallintOrd('n').getEqlType()).toBe('public.smallint_ord') + + expect(types.Boolean('b').getEqlType()).toBe('public.boolean') + expect(types.Real('n').getEqlType()).toBe('public.real') + expect(types.RealEq('n').getEqlType()).toBe('public.real_eq') + expect(types.RealOrdOre('n').getEqlType()).toBe('public.real_ord_ore') + expect(types.RealOrd('n').getEqlType()).toBe('public.real_ord') + expect(types.Double('n').getEqlType()).toBe('public.double') + expect(types.DoubleEq('n').getEqlType()).toBe('public.double_eq') + expect(types.DoubleOrdOre('n').getEqlType()).toBe('public.double_ord_ore') + expect(types.DoubleOrd('n').getEqlType()).toBe('public.double_ord') + }) +}) + describe('eql_v3 encryptedTable', () => { it('creates a table exposing column builders as properties', () => { const users = encryptedTable('users', { @@ -401,8 +427,10 @@ describe('eql_v3 equality via ORE on order-capable columns (regression)', () => // 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.) + // Keep these labels aligned with the checked-in EQL build; a mismatch here + // means the stack package is out of sync with the underlying domain surface. it.each([ - ['int4_ord', types.Int4Ord], + ['IntegerOrd', types.IntegerOrd], ['date_ord', types.DateOrd], ['numeric_ord', types.NumericOrd], ] as const)('%s resolves equality to the ore index', (_name, builder) => { @@ -422,12 +450,12 @@ describe('eql_v3 equality via ORE on order-capable columns (regression)', () => }) 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 + // The `public.text_ord` and `public.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`. + // fails with `value for domain public.text_ord_ore violates check constraint`. it.each([ ['text_ord_ore', types.TextOrdOre], ['text_ord', types.TextOrd], @@ -439,8 +467,8 @@ describe('eql_v3 text order domains carry the hm (unique) index (regression)', ( }) it.each([ - ['int4_ord_ore', types.Int4OrdOre], - ['int4_ord', types.Int4Ord], + ['IntegerOrdOre', types.IntegerOrdOre], + ['IntegerOrd', types.IntegerOrd], ['date_ord_ore', types.DateOrdOre], ['numeric_ord', types.NumericOrd], ] as const)('%s (numeric/date order) emits ore only — no unique', (_name, builder) => { diff --git a/packages/stack/__tests__/typed-client-v3.test-d.ts b/packages/stack/__tests__/typed-client-v3.test-d.ts index 2275ebce..03b929c9 100644 --- a/packages/stack/__tests__/typed-client-v3.test-d.ts +++ b/packages/stack/__tests__/typed-client-v3.test-d.ts @@ -19,10 +19,10 @@ const users = encryptedTable('users', { createdAt: types.TimestampOrd('created_at'), // equality + order }) -// A second registered table whose `weight` domain (int4_ord) is NOT present in +// 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.Int4Ord('weight'), + weight: types.IntegerOrd('weight'), }) const client = typedClient({} as EncryptionClient, users, other) @@ -166,7 +166,7 @@ describe('typed v3 client — soundness', () => { // error is the column itself failing the `ColumnsOf` constraint. client.encrypt('x', { table: users, - // @ts-expect-error - int4_ord column from `other` is not in ColumnsOf + // @ts-expect-error - integer_ord column from `other` is not in ColumnsOf column: other.weight, }) }) diff --git a/packages/stack/__tests__/v3-matrix/catalog.ts b/packages/stack/__tests__/v3-matrix/catalog.ts index 64155075..d0bd8d22 100644 --- a/packages/stack/__tests__/v3-matrix/catalog.ts +++ b/packages/stack/__tests__/v3-matrix/catalog.ts @@ -23,31 +23,31 @@ import type { QueryCapabilities, } from '@/eql/v3' import { - EncryptedBoolColumn, + EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, EncryptedDateOrdColumn, EncryptedDateOrdOreColumn, - EncryptedFloat4Column, - EncryptedFloat4EqColumn, - EncryptedFloat4OrdColumn, - EncryptedFloat4OrdOreColumn, - EncryptedFloat8Column, - EncryptedFloat8EqColumn, - EncryptedFloat8OrdColumn, - EncryptedFloat8OrdOreColumn, - EncryptedInt2Column, - EncryptedInt2EqColumn, - EncryptedInt2OrdColumn, - EncryptedInt2OrdOreColumn, - EncryptedInt4Column, - EncryptedInt4EqColumn, - EncryptedInt4OrdColumn, - EncryptedInt4OrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, EncryptedNumericColumn, EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, @@ -96,7 +96,7 @@ export type DomainSpec = Readonly<{ * 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 `int4` from `float8`, and a fractional value on an int-named domain is + * 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 @@ -172,11 +172,11 @@ const TEXT_SEARCH_IDX: Indexes = { // Sample plaintexts per plaintext axis, consumed by `matrix-live.test.ts`. // Numeric sets are split by domain width: integers (incl. type bounds) for -// int2/int4, fractionals for float4/float8/numeric. See `DomainSpec.samples`. -const INT2_S = [0, -1, 32767, -32768] as const -const INT4_S = [0, -42, 2147483647, -2147483648] as const -const FLOAT4_S = [0, 77.5, -117.25, 0.5] as const -const FLOAT8_S = [0, -117.123456, 1e15, -1e15] as const +// 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 // Text domains with an ORE (`ob`) term require non-empty positive samples to @@ -187,7 +187,7 @@ const TEXT_ORE_S = [ 'grace@example.com', 'zora@example.org', ] as const -const BOOL_S = [true, false] 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'), @@ -210,48 +210,48 @@ const NUM_ERR = [ // biome-ignore format: one row per domain reads as a table; keep it dense. export const V3_MATRIX = { - // int4 - 'eql_v3.int4': { builder: types.Int4, ColumnClass: EncryptedInt4Column, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: INT4_S, errorSamples: NUM_ERR }, - 'eql_v3.int4_eq': { builder: types.Int4Eq, ColumnClass: EncryptedInt4EqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: INT4_S, errorSamples: NUM_ERR }, - 'eql_v3.int4_ord_ore': { builder: types.Int4OrdOre, ColumnClass: EncryptedInt4OrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INT4_S, errorSamples: NUM_ERR }, - 'eql_v3.int4_ord': { builder: types.Int4Ord, ColumnClass: EncryptedInt4OrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INT4_S, errorSamples: NUM_ERR }, - // int2 - 'eql_v3.int2': { builder: types.Int2, ColumnClass: EncryptedInt2Column, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: INT2_S, errorSamples: NUM_ERR }, - 'eql_v3.int2_eq': { builder: types.Int2Eq, ColumnClass: EncryptedInt2EqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: INT2_S, errorSamples: NUM_ERR }, - 'eql_v3.int2_ord_ore': { builder: types.Int2OrdOre, ColumnClass: EncryptedInt2OrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INT2_S, errorSamples: NUM_ERR }, - 'eql_v3.int2_ord': { builder: types.Int2Ord, ColumnClass: EncryptedInt2OrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INT2_S, errorSamples: NUM_ERR }, + // integer + 'public.integer': { builder: types.Integer, ColumnClass: EncryptedIntegerColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: INTEGER_S, errorSamples: NUM_ERR }, + 'public.integer_eq': { builder: types.IntegerEq, ColumnClass: EncryptedIntegerEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, + 'public.integer_ord_ore': { builder: types.IntegerOrdOre, ColumnClass: EncryptedIntegerOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, + 'public.integer_ord': { builder: types.IntegerOrd, ColumnClass: EncryptedIntegerOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, + // smallint + 'public.smallint': { builder: types.Smallint, ColumnClass: EncryptedSmallintColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: SMALLINT_S, errorSamples: NUM_ERR }, + 'public.smallint_eq': { builder: types.SmallintEq, ColumnClass: EncryptedSmallintEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, + 'public.smallint_ord_ore': { builder: types.SmallintOrdOre, ColumnClass: EncryptedSmallintOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, + 'public.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 }, + 'public.date': { builder: types.Date, ColumnClass: EncryptedDateColumn, castAs: 'date', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, + 'public.date_eq': { builder: types.DateEq, ColumnClass: EncryptedDateEqColumn, castAs: 'date', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, + 'public.date_ord_ore': { builder: types.DateOrdOre, ColumnClass: EncryptedDateOrdOreColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, + 'public.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: TS_S }, - 'eql_v3.timestamp_eq': { builder: types.TimestampEq, ColumnClass: EncryptedTimestampEqColumn, castAs: 'timestamp', capabilities: EQ, indexes: UNIQUE_IDX, samples: TS_S }, - 'eql_v3.timestamp_ord_ore': { builder: types.TimestampOrdOre, ColumnClass: EncryptedTimestampOrdOreColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: TS_S }, - 'eql_v3.timestamp_ord': { builder: types.TimestampOrd, ColumnClass: EncryptedTimestampOrdColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: TS_S }, + 'public.timestamp': { builder: types.Timestamp, ColumnClass: EncryptedTimestampColumn, castAs: 'timestamp', capabilities: STORAGE, indexes: NONE, samples: TS_S }, + 'public.timestamp_eq': { builder: types.TimestampEq, ColumnClass: EncryptedTimestampEqColumn, castAs: 'timestamp', capabilities: EQ, indexes: UNIQUE_IDX, samples: TS_S }, + 'public.timestamp_ord_ore': { builder: types.TimestampOrdOre, ColumnClass: EncryptedTimestampOrdOreColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: TS_S }, + 'public.timestamp_ord': { builder: types.TimestampOrd, ColumnClass: EncryptedTimestampOrdColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: TS_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 }, + 'public.numeric': { builder: types.Numeric, ColumnClass: EncryptedNumericColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'public.numeric_eq': { builder: types.NumericEq, ColumnClass: EncryptedNumericEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'public.numeric_ord_ore': { builder: types.NumericOrdOre, ColumnClass: EncryptedNumericOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'public.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_ORE_S }, - 'eql_v3.text_ord': { builder: types.TextOrd, ColumnClass: EncryptedTextOrdColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORE_S }, - 'eql_v3.text_search': { builder: types.TextSearch, ColumnClass: EncryptedTextSearchColumn, castAs: 'string', capabilities: FULL, indexes: TEXT_SEARCH_IDX, samples: TEXT_ORE_S }, - // bool - 'eql_v3.bool': { builder: types.Bool, ColumnClass: EncryptedBoolColumn, castAs: 'boolean', capabilities: STORAGE, indexes: NONE, samples: BOOL_S }, - // float4 - 'eql_v3.float4': { builder: types.Float4, ColumnClass: EncryptedFloat4Column, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: FLOAT4_S, errorSamples: NUM_ERR }, - 'eql_v3.float4_eq': { builder: types.Float4Eq, ColumnClass: EncryptedFloat4EqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: FLOAT4_S, errorSamples: NUM_ERR }, - 'eql_v3.float4_ord_ore': { builder: types.Float4OrdOre, ColumnClass: EncryptedFloat4OrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: FLOAT4_S, errorSamples: NUM_ERR }, - 'eql_v3.float4_ord': { builder: types.Float4Ord, ColumnClass: EncryptedFloat4OrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: FLOAT4_S, errorSamples: NUM_ERR }, - // float8 - 'eql_v3.float8': { builder: types.Float8, ColumnClass: EncryptedFloat8Column, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: FLOAT8_S, errorSamples: NUM_ERR }, - 'eql_v3.float8_eq': { builder: types.Float8Eq, ColumnClass: EncryptedFloat8EqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: FLOAT8_S, errorSamples: NUM_ERR }, - 'eql_v3.float8_ord_ore': { builder: types.Float8OrdOre, ColumnClass: EncryptedFloat8OrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: FLOAT8_S, errorSamples: NUM_ERR }, - 'eql_v3.float8_ord': { builder: types.Float8Ord, ColumnClass: EncryptedFloat8OrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: FLOAT8_S, errorSamples: NUM_ERR }, + 'public.text': { builder: types.Text, ColumnClass: EncryptedTextColumn, castAs: 'string', capabilities: STORAGE, indexes: NONE, samples: TEXT_S }, + 'public.text_eq': { builder: types.TextEq, ColumnClass: EncryptedTextEqColumn, castAs: 'string', capabilities: EQ, indexes: UNIQUE_IDX, samples: TEXT_S }, + 'public.text_match': { builder: types.TextMatch, ColumnClass: EncryptedTextMatchColumn, castAs: 'string', capabilities: MATCH_ONLY, indexes: MATCH_IDX, samples: TEXT_S }, + 'public.text_ord_ore': { builder: types.TextOrdOre, ColumnClass: EncryptedTextOrdOreColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORE_S }, + 'public.text_ord': { builder: types.TextOrd, ColumnClass: EncryptedTextOrdColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORE_S }, + 'public.text_search': { builder: types.TextSearch, ColumnClass: EncryptedTextSearchColumn, castAs: 'string', capabilities: FULL, indexes: TEXT_SEARCH_IDX, samples: TEXT_ORE_S }, + // boolean + 'public.boolean': { builder: types.Boolean, ColumnClass: EncryptedBooleanColumn, castAs: 'boolean', capabilities: STORAGE, indexes: NONE, samples: BOOLEAN_S }, + // real + 'public.real': { builder: types.Real, ColumnClass: EncryptedRealColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: REAL_S, errorSamples: NUM_ERR }, + 'public.real_eq': { builder: types.RealEq, ColumnClass: EncryptedRealEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, + 'public.real_ord_ore': { builder: types.RealOrdOre, ColumnClass: EncryptedRealOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, + 'public.real_ord': { builder: types.RealOrd, ColumnClass: EncryptedRealOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, + // double + 'public.double': { builder: types.Double, ColumnClass: EncryptedDoubleColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: DOUBLE_S, errorSamples: NUM_ERR }, + 'public.double_eq': { builder: types.DoubleEq, ColumnClass: EncryptedDoubleEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, + 'public.double_ord_ore': { builder: types.DoubleOrdOre, ColumnClass: EncryptedDoubleOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, + 'public.double_ord': { builder: types.DoubleOrd, ColumnClass: EncryptedDoubleOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, } as const satisfies Record diff --git a/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts b/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts index 6c815da6..61915f15 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts @@ -13,7 +13,7 @@ import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' const people = encryptedTable('v3_bulk_people', { nickname: types.TextEq('nickname'), - age: types.Int4Ord('age'), + age: types.IntegerOrd('age'), }) describeLive('v3 typed client bulk-at-scale (live)', () => { diff --git a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts index 6793e0a5..5a69f32c 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts @@ -17,24 +17,40 @@ * 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 (any `unique`/`hm` domain): `eql_v3.eq_term` + `hmac_256` - * - ord (any `ore`/`ob` domain): `eql_v3.ord_term` + `ore_block_256`. - * Pure-ORE domains (numeric/date `*_ord`/`*_ord_ore`) are queried with - * `queryType:'equality'` — the equality-via-ORE path Part A fixed — because - * `ob` is their only index and they have no `eq_term` at all in the real - * `eql_v3` SQL (verified against the fixture). Text order domains carry BOTH - * `hm` and `ob`, so they run the eq proof AND the ord proof; their `ob` term - * is built with `queryType:'orderAndRange'` (equality would resolve to `hm`). + * and not the other. Queries use the supported EQL v3 API: a FULL encrypted + * operand (`client.encrypt`, same payload as storage) compared against the + * column with a public two-arg `eql_v3.*(col, operand::jsonb)` function. (The + * old `encryptQuery` scalar-term path is unsupported in protect-ffi 0.28 — + * `EQL_V3_QUERY_UNSUPPORTED` — and the operand carries every index term, so the + * SQL function per proof, not a `queryType`, selects which term is compared.) + * Dispatch mirrors the priority `resolveIndexType` uses (match > unique > ore): + * - match (text_match, text_search): `eql_v3.contains(col, operand)` + * - eq (any `unique` domain): `eql_v3.eq(col, operand)` + * - ord (any `ore` domain): ORE range `eql_v3.gte(col,op) AND + * eql_v3.lte(col,op)`. Pure-ORE numeric/date `*_ord`/`*_ord_ore` domains + * have no `hm` term, so `eql_v3.eq` there resolves to `ord_term` — that IS + * the equality-via-ORE proof — while text order domains carry BOTH `hm` and + * `ob`, so they use the explicit range to exercise `ob` (a bare `eql_v3.eq` + * would silently compare `hm`). Text order domains also run the eq proof. * - 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. + * + * In addition, EVERY ORE ordering domain (every `ore`-indexed domain: all + * `_ord`/`_ord_ore` numeric/date/timestamp domains plus `text_ord`, + * `text_ord_ore` and `text_search`) gets a STRICT total-order proof. Its + * distinct sample values are each seeded as their own row (under a separate + * `ORDER_RUN_ID`, so the two-row proofs above are unaffected) and the boolean + * `eql_v3.lt` comparison is used — via a self cross-join ranking — to prove the + * ORE order reproduces the full plaintext order (a `int4_ord`: a valid, unique Postgres column name. */ -const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') +/** `public.integer_ord` -> `integer_ord`: a valid, unique Postgres column name. + * The domains were renamed `eql_v3.* -> public.*`, so strip the `public.` + * prefix — a leftover dot in the column name breaks both the FFI's identifier + * resolution and the `"col" ` DDL below. */ +const slug = (t: EqlV3TypeName): string => t.replace(/^public\./, '') const expectDecryptedStorageValue = ( decrypted: unknown, @@ -108,7 +127,7 @@ const table = encryptedTable(TABLE_NAME, columns as never) const hasIndex = ( indexes: DomainSpec['indexes'], key: 'unique' | 'ore' | 'match', -): boolean => Boolean((indexes ?? {})[key]) +): boolean => Boolean(indexes?.[key]) const matchDomains = domains.filter(([, spec]) => hasIndex(spec.indexes, 'match'), @@ -129,16 +148,55 @@ const storageDomains = domains.filter( ) const textOreDomains = domains.filter( ([t]) => - t === 'eql_v3.text_ord_ore' || - t === 'eql_v3.text_ord' || - t === 'eql_v3.text_search', + t === 'public.text_ord_ore' || + t === 'public.text_ord' || + t === 'public.text_search', +) + +// EVERY ORE ordering domain: all `_ord`/`_ord_ore` numeric/date/timestamp +// domains PLUS the three text order domains (`text_ord`, `text_ord_ore`, +// `text_search`) — i.e. every domain carrying an `ore` index. `text_search` +// is intentionally INCLUDED here (unlike `ordDomains`, which excludes it so +// its canonical proof stays the match one): strict ORE ordering is a real +// capability of that domain and gets its own proof below. +const orderingDomains = domains.filter(([, spec]) => + hasIndex(spec.indexes, 'ore'), ) +// The number of separate ordering rows to seed: the widest ordering domain's +// distinct sample count (numeric domains carry 4; text carries 3; date/ +// timestamp carry 2). Narrower domains reuse their last sample in the extra +// rows (harmless — each per-domain proof only reads its own first N rows). +const MAX_ORDER_ROWS = Math.max( + ...orderingDomains.map(([, spec]) => spec.samples.length), +) + +/** Plaintext ordering used to derive the EXPECTED ORE order per domain. + * Dates compare by instant, numbers numerically, strings by code point (ORE + * text order is byte order, which matches JS `<` for the ASCII samples here). */ +const comparePlaintext = (a: unknown, b: unknown): number => { + if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime() + if (typeof a === 'number' && typeof b === 'number') return a - b + const sa = String(a) + const sb = String(b) + return sa < sb ? -1 : sa > sb ? 1 : 0 +} + type Row = { id: number } let client: Awaited> let idA: number let idB: number +// Separate run id for the multi-row ordering rows. Kept DISTINCT from +// TEST_RUN_ID so the existing eq/match/storage/ord proofs (which filter on +// TEST_RUN_ID and expect exactly the two idA/idB rows) never see these extra +// rows — e.g. the `text_match` "contains ada" proof would otherwise also match +// a downcased 'Ada Lovelace' row. +const ORDER_RUN_ID = `${TEST_RUN_ID}-order` +// Row ids of the seeded ordering rows, in sample-index order: orderIds[i] +// holds `samples[min(i, L-1)]` for every domain, so orderIds[0..L-1] map 1:1 +// to a domain's distinct samples[0..L-1]. +let orderIds: number[] = [] // Query terms, pre-encrypted once in `beforeAll` (not per `it.each` case). const eqTerms: Record = {} const ordTerms: Record = {} @@ -154,6 +212,12 @@ beforeAll(async () => { .map(([t]) => `"${slug(t)}" ${t} NOT NULL`) .join(',\n ') + // DROP first: the table is created with IF NOT EXISTS and cleaned up by row + // DELETE only, so a table left by an earlier local run keeps its OLD column + // domain types across the `eql_v3.* -> public.*` / `timestamptz -> timestamp` + // renames — silently testing against a stale schema. Harmless in CI (fresh + // Postgres each run); load-bearing for reliable local reruns. + await sql.unsafe(`DROP TABLE IF EXISTS ${TABLE_NAME}`) await sql.unsafe(` CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, @@ -162,21 +226,31 @@ beforeAll(async () => { ) `) - // 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 = {} - const rowB: Record = {} - for (const [t, spec] of domains) { - rowA[slug(t)] = spec.samples[0] - rowB[slug(t)] = spec.samples[1] - } + // Model rows for the ordering proofs: row i carries `samples[min(i, L-1)]` + // for every domain (`L` = that domain's sample count). Rows 0/1 double as the + // classic two-row seed (samples[0]/samples[1]) reused by the existing proofs; + // rows 2..MAX_ORDER_ROWS-1 give the extra distinct values numeric/text + // ordering domains need for a full a { + const row: Record = {} + for (const [t, spec] of domains) { + row[slug(t)] = spec.samples[Math.min(i, spec.samples.length - 1)] + } + return row + }) - const [encA, encB] = unwrapResult( - await client.bulkEncryptModels([rowA, rowB] as never, table as never), + const encModels = unwrapResult( + await client.bulkEncryptModels(models as never, table as never), ) as Array> const colNames = domains.map(([t]) => `"${slug(t)}"`) - const insertRow = async (enc: Record): Promise => { + const insertRow = async ( + enc: Record, + runId: string, + ): Promise => { 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 — @@ -188,76 +262,53 @@ beforeAll(async () => { `INSERT INTO ${TABLE_NAME} (test_run_id, ${colNames.join(', ')}) VALUES ($1, ${casts.join(', ')}) RETURNING id`, - [TEST_RUN_ID, ...values], + [runId, ...values], ) return row.id } - idA = await insertRow(encA) - idB = await insertRow(encB) + idA = await insertRow(encModels[0], TEST_RUN_ID) + idB = await insertRow(encModels[1], TEST_RUN_ID) + orderIds = [] + for (const enc of encModels) { + orderIds.push(await insertRow(enc, ORDER_RUN_ID)) + } const columnRef = (t: EqlV3TypeName) => (table as unknown as Record)[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`), 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 client.encryptQuery( - spec.samples[0] as never, - { - table, - column: columnRef(t), - queryType: 'equality', - } as never, - ), + // Query operands are FULL encrypted payloads — the same thing `client.encrypt` + // produces for storage — NOT `encryptQuery` terms. protect-ffi 0.28 has no v3 + // scalar query wire shape (`encryptQuery` throws EQL_V3_QUERY_UNSUPPORTED), so + // the supported path is to encrypt the search value as an operand and compare + // it with the public two-arg `eql_v3.*(col, operand::jsonb)` functions in SQL. + // The full operand carries every index term, so `queryType` dispatch is gone — + // the SQL function chosen per proof (eq / gte+lte / contains) selects which + // term the comparison uses. `opts` is cast `as never` because these columns + // are built dynamically (`Object.fromEntries`) and carry no static type. + const encryptOperand = async (t: EqlV3TypeName, value: unknown) => + unwrapResult( + await client.encrypt(value as never, { + table, + column: columnRef(t), + } as never), ) + for (const [t, spec] of eqDomains) { + eqTerms[slug(t)] = await encryptOperand(t, spec.samples[0]) } for (const [t, spec] of ordDomains) { - // Pure-ORE domains (numeric/date) answer equality via ORE, so - // `queryType:'equality'` resolves to the `ob` term — the exact - // equality-via-ORE path Part A fixed. Text order domains ALSO carry `hm`, - // where `equality` resolves to HMAC by the shared `unique > … > ore` - // priority; force `orderAndRange` there so the term still carries the `ob` - // this proof extracts with `ore_block_256`. - const queryType = hasIndex(spec.indexes, 'unique') - ? 'orderAndRange' - : 'equality' - ordTerms[slug(t)] = unwrapResult( - await client.encryptQuery( - spec.samples[0] as never, - { - table, - column: columnRef(t), - queryType, - } as never, - ), - ) + ordTerms[slug(t)] = await encryptOperand(t, spec.samples[0]) } - // text_match/text_search: query a substring of whichever seeded sample - // contains "ada". `text_match` still uses the shared TEXT_S with an empty row - // A, while `text_search` uses non-empty TEXT_ORE_S to satisfy its `ob` check. + // text_match/text_search: query the substring "ada", present only in the + // seeded sample of exactly one row per domain. for (const [t] of matchDomains) { - matchTerms[slug(t)] = unwrapResult( - await client.encryptQuery( - 'ada' as never, - { - table, - column: columnRef(t), - queryType: 'freeTextSearch', - } as never, - ), - ) + matchTerms[slug(t)] = await encryptOperand(t, 'ada') } }, 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.unsafe(`DELETE FROM ${TABLE_NAME} WHERE test_run_id = ANY($1)`, [ + [TEST_RUN_ID, ORDER_RUN_ID], ]) await sql.end() }, 30000) @@ -265,12 +316,12 @@ afterAll(async () => { describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { it.each( eqDomains, - )('%s: eq_term/hmac_256 selects the exact row', async (eqlType) => { + )('%s: eql_v3.eq(col, operand) selects the exact row', async (eqlType) => { const col = slug(eqlType) const rows = await sql.unsafe( `SELECT id FROM ${TABLE_NAME} WHERE test_run_id = $1 - AND eql_v3.eq_term("${col}") = eql_v3.hmac_256($2::jsonb)`, + AND eql_v3.eq("${col}", $2::jsonb)`, [TEST_RUN_ID, sql.json(eqTerms[col] as never)], ) expect(rows.map((r) => r.id)).toEqual([idA]) @@ -278,12 +329,21 @@ describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { it.each( ordDomains, - )('%s: ord_term/ore_block_256 equality-via-ORE selects the exact row', async (eqlType) => { + )('%s: ORE range selects the exact row', async (eqlType, spec) => { const col = slug(eqlType) + // The proof must exercise the ORDER (`ob`) term, not equality. On text order + // domains (`text_ord`/`text_ord_ore`, which carry BOTH `unique` and `ore`) + // `eql_v3.eq` compares the `hm` term, so pin the ORE term with a degenerate + // range `col >= operand AND col <= operand` (both `ord_term`-based) — it + // selects the equal row via ORE. Pure-ORE numeric/date domains have no `hm`, + // so `eql_v3.eq` resolves to `ord_term`: that IS the equality-via-ORE proof. + const predicate = hasIndex(spec.indexes, 'unique') + ? `eql_v3.gte("${col}", $2::jsonb) AND eql_v3.lte("${col}", $2::jsonb)` + : `eql_v3.eq("${col}", $2::jsonb)` const rows = await sql.unsafe( `SELECT id FROM ${TABLE_NAME} WHERE test_run_id = $1 - AND eql_v3.ord_term("${col}") = eql_v3.ore_block_256($2::jsonb)`, + AND ${predicate}`, [TEST_RUN_ID, sql.json(ordTerms[col] as never)], ) expect(rows.map((r) => r.id)).toEqual([idA]) @@ -308,18 +368,76 @@ describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { it.each( matchDomains, - )('%s: match_term/bloom_filter selects the row containing "ada"', async (eqlType, spec) => { + )('%s: eql_v3.contains selects the row containing "ada"', async (eqlType, spec) => { const col = slug(eqlType) const expectedId = String(spec.samples[0]).includes('ada') ? idA : idB const rows = await sql.unsafe( `SELECT id FROM ${TABLE_NAME} WHERE test_run_id = $1 - AND eql_v3.match_term("${col}") @> eql_v3.bloom_filter($2::jsonb)`, + AND eql_v3.contains("${col}", $2::jsonb)`, [TEST_RUN_ID, sql.json(matchTerms[col] as never)], ) expect(rows.map((r) => r.id)).toEqual([expectedId]) }) + it.each( + orderingDomains, + )('%s: ORE pairwise-lt reproduces plaintext order across all distinct samples', async (eqlType, spec) => { + // STRICT ordering proof: seed each of a domain's distinct sample values as + // its OWN row (orderIds[0..L-1] ↔ samples[0..L-1]) and prove the ORE + // comparison reproduces the FULL plaintext order (a orderIds[i]). + const expectedAscending = spec.samples + .map((value, i) => ({ value, id: ids[i] })) + .sort((x, y) => comparePlaintext(x.value, y.value)) + .map((entry) => entry.id) + + const pairs = await sql.unsafe>( + `SELECT x.id AS a, y.id AS b, eql_v3.lt(x."${col}", y."${col}") AS lt + FROM ${TABLE_NAME} x + CROSS JOIN ${TABLE_NAME} y + WHERE x.test_run_id = $1 + AND y.test_run_id = $1 + AND x.id = ANY($2) + AND y.id = ANY($2) + AND x.id <> y.id`, + [ORDER_RUN_ID, ids], + ) + + const lessThanCount = new Map(ids.map((id) => [id, 0])) + for (const pair of pairs) { + if (pair.lt) { + lessThanCount.set(pair.a, (lessThanCount.get(pair.a) ?? 0) + 1) + } + } + + // Ascending rank = strictly-less-than count, descending (the smallest value + // is < every other row, so it has the highest count and sorts first). + const derivedAscending = [...ids].sort( + (a, b) => (lessThanCount.get(b) ?? 0) - (lessThanCount.get(a) ?? 0), + ) + + // Sanity: distinct samples must yield distinct ranks 0..L-1 (a strict total + // order), otherwise the ORE comparison collapsed two values together. + expect(new Set(lessThanCount.values()).size).toBe(L) + expect(derivedAscending).toEqual(expectedAscending) + }) + it.each( storageDomains, )('%s: ciphertext survives a real INSERT/SELECT and still decrypts', async (eqlType, spec) => { diff --git a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts index 0a8a2e35..c0082fbf 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts @@ -18,10 +18,10 @@ * 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 { beforeAll, expect, it } from 'vitest' import { EncryptionV3, encryptedTable } from '@/encryption/v3' import { unwrapResult } from '../fixtures' -import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' +import { describeLive } from '../helpers/live-gate' import { type DomainSpec, type EqlV3TypeName, @@ -29,8 +29,11 @@ import { V3_MATRIX, } from './catalog' -/** `eql_v3.int4_ord` → `int4_ord`: a valid, per-domain-unique column name. */ -const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') +/** `public.integer_ord` -> `integer_ord`: a valid, per-domain-unique column name. + * The domains were renamed `eql_v3.* -> public.*`, so strip the `public.` + * prefix — a leftover dot in the column name (`public.integer_ord`) makes the + * FFI's identifier resolution fail every encrypt. */ +const slug = (t: EqlV3TypeName): string => t.replace(/^public\./, '') // `as const satisfies Record<...>` gives `V3_MATRIX` a narrower type than // `Record` (rows that omit the optional diff --git a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts index 324cd960..02bfdbd0 100644 --- a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts +++ b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts @@ -22,12 +22,12 @@ 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.int4'].builder('count'), // number, storage-only - score: V3_MATRIX['eql_v3.int4_eq'].builder('score'), // number, equality - rank: V3_MATRIX['eql_v3.int4_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.bool'].builder('active'), // boolean, storage-only + count: V3_MATRIX['public.integer'].builder('count'), // number, storage-only + score: V3_MATRIX['public.integer_eq'].builder('score'), // number, equality + rank: V3_MATRIX['public.integer_ord'].builder('rank'), // number, order + range + createdAt: V3_MATRIX['public.timestamp_ord'].builder('created_at'), // date + email: V3_MATRIX['public.text_search'].builder('email'), // string, full-text + active: V3_MATRIX['public.boolean'].builder('active'), // boolean, storage-only }) describe('eql_v3 type-driven matrix (types)', () => { @@ -67,23 +67,24 @@ describe('eql_v3 type-driven matrix (types)', () => { type Queryable = QueryableColumnsOf // A queryable column is a member of the set... - const ok: Queryable = V3_MATRIX['eql_v3.int4_eq'].builder('score') + const ok: Queryable = V3_MATRIX['public.integer_eq'].builder('score') expectTypeOf(ok).toExtend() // ...but a storage-only column is not. - // @ts-expect-error - storage-only int4 column is excluded from QueryableColumnsOf - const _notQueryable: Queryable = V3_MATRIX['eql_v3.int4'].builder('count') + // @ts-expect-error - storage-only integer column is excluded from QueryableColumnsOf + const _notQueryable: Queryable = + V3_MATRIX['public.integer'].builder('count') - // @ts-expect-error - storage-only bool column is excluded from QueryableColumnsOf + // @ts-expect-error - storage-only boolean column is excluded from QueryableColumnsOf const _boolNotQueryable: Queryable = - V3_MATRIX['eql_v3.bool'].builder('active') + V3_MATRIX['public.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() - expectTypeOf<'eql_v3.bool'>().toExtend() + expectTypeOf<'public.text_search'>().toExtend() + expectTypeOf<'public.boolean'>().toExtend() // A key outside the real domain set is rejected — this is what makes the // `Record` catalog a compile-time coverage check. diff --git a/packages/stack/__tests__/v3-matrix/matrix.test.ts b/packages/stack/__tests__/v3-matrix/matrix.test.ts index cbecb2a0..0c788ecb 100644 --- a/packages/stack/__tests__/v3-matrix/matrix.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix.test.ts @@ -35,9 +35,9 @@ describe('eql_v3 type-driven domain matrix (runtime)', () => { }) it.each([ - 'eql_v3.text_ord_ore', - 'eql_v3.text_ord', - 'eql_v3.text_search', + 'public.text_ord_ore', + 'public.text_ord', + 'public.text_search', ] as const)('%s uses non-empty positive samples for live Postgres inserts', (eqlType) => { expect(V3_MATRIX[eqlType].samples[0]).not.toBe('') }) @@ -50,10 +50,10 @@ describe('eql_v3 type-driven domain matrix (runtime)', () => { // the live suite's truncation-detection power at build time — flip the // timestamp rows back to `DATE_S` and this fails. it.each([ - 'eql_v3.timestamp', - 'eql_v3.timestamp_eq', - 'eql_v3.timestamp_ord_ore', - 'eql_v3.timestamp_ord', + 'public.timestamp', + 'public.timestamp_eq', + 'public.timestamp_ord_ore', + 'public.timestamp_ord', ] as const)('%s carries a sample with a non-zero time-of-day', (eqlType) => { const samples = V3_MATRIX[eqlType].samples as readonly Date[] const hasTimeOfDay = (d: Date) => diff --git a/packages/stack/package.json b/packages/stack/package.json index 872c459f..600bf575 100644 --- a/packages/stack/package.json +++ b/packages/stack/package.json @@ -244,7 +244,7 @@ "dependencies": { "@byteslice/result": "0.2.0", "@cipherstash/auth": "catalog:repo", - "@cipherstash/protect-ffi": "0.26.0", + "@cipherstash/protect-ffi": "0.28.0", "evlog": "1.11.0", "uuid": "14.0.0", "zod": "3.25.76" 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/index.ts b/packages/stack/src/encryption/index.ts index bf5a08ee..db9fa5dd 100644 --- a/packages/stack/src/encryption/index.ts +++ b/packages/stack/src/encryption/index.ts @@ -87,6 +87,7 @@ export class EncryptionClient { clientKey?: string keyset?: KeysetIdentifier strategy?: AuthStrategy + eqlVersion?: 2 | 3 }): Promise> { return await withResult( async () => { @@ -118,6 +119,10 @@ export class EncryptionClient { keyset: toFfiKeysetIdentifier(config.keyset), }, strategy: config.strategy, + // Selects the EQL wire format. Omitted (undefined) → protect-ffi + // defaults to v2. v3 concrete-type schemas require 3; EncryptionV3 + // sets it, and without it every v3 encrypt fails inside the FFI. + eqlVersion: config.eqlVersion, }) this.encryptConfig = validated diff --git a/packages/stack/src/encryption/operations/batch-encrypt-query.ts b/packages/stack/src/encryption/operations/batch-encrypt-query.ts index 1c4bff5c..00f65a0b 100644 --- a/packages/stack/src/encryption/operations/batch-encrypt-query.ts +++ b/packages/stack/src/encryption/operations/batch-encrypt-query.ts @@ -82,13 +82,17 @@ function buildQueryPayload( */ function assembleResults( totalLength: number, - encryptedValues: (CipherStashEncrypted | CipherStashEncryptedQuery)[], + // Typed as the FFI bulk-query return so it tracks the upstream union. As of + // protect-ffi 0.27 that union also includes `SteVecQuery`, but scalar query + // terms (all this operation builds) never produce a ste_vec result, so each + // element is narrowed back to the scalar shape `formatEncryptedResult` takes. + encryptedValues: Awaited>, nonNullTerms: { term: ScalarQueryTerm; originalIndex: number }[], ): EncryptedQueryResult[] { const results: EncryptedQueryResult[] = new Array(totalLength).fill(null) nonNullTerms.forEach(({ term, originalIndex }, i) => { results[originalIndex] = formatEncryptedResult( - encryptedValues[i], + encryptedValues[i] as CipherStashEncrypted | CipherStashEncryptedQuery, term.returnType, ) }) diff --git a/packages/stack/src/encryption/v3.ts b/packages/stack/src/encryption/v3.ts index 385b964c..eb45bd96 100644 --- a/packages/stack/src/encryption/v3.ts +++ b/packages/stack/src/encryption/v3.ts @@ -259,7 +259,11 @@ export async function EncryptionV3< schemas: config.schemas as unknown as Parameters< typeof Encryption >[0]['schemas'], - config: config.config, + // Force the v3 EQL wire format. protect-ffi's newClient defaults to + // eqlVersion 2; a v2-mode client cannot resolve v3 concrete-type columns + // and fails every encrypt with "Cannot convert undefined or null to + // object". This is a v3-only invariant, so it overrides any user value. + config: { ...config.config, eqlVersion: 3 }, }) return typedClient(client, ...config.schemas) } diff --git a/packages/stack/src/eql/v3/columns.ts b/packages/stack/src/eql/v3/columns.ts index a1c70eed..a5e75a61 100644 --- a/packages/stack/src/eql/v3/columns.ts +++ b/packages/stack/src/eql/v3/columns.ts @@ -47,11 +47,11 @@ type PlaintextKind = 'string' | 'number' | 'boolean' | DateLikeCast * 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 `bool` column would be assignable to + * 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}` + eqlType: `public.${string}` castAs: PlaintextKind capabilities: QueryCapabilities }> @@ -101,7 +101,7 @@ const TEXT_SEARCH = { * 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' +export const TEXT_SEARCH_EQL_TYPE = 'public.text_search' // Per-domain literal definitions. Each concrete column subclass is parameterised // by `typeof `; the literal `eqlType`/`castAs`/`capabilities` on each is @@ -110,188 +110,181 @@ export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' // // 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 INT4 = { - eqlType: 'eql_v3.int4', +export const INTEGER = { + eqlType: 'public.integer', castAs: 'number', capabilities: STORAGE_ONLY, } as const -export const INT4_EQ = { - eqlType: 'eql_v3.int4_eq', +export const INTEGER_EQ = { + eqlType: 'public.integer_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const -export const INT4_ORD_ORE = { - eqlType: 'eql_v3.int4_ord_ore', +export const INTEGER_ORD_ORE = { + eqlType: 'public.integer_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -export const INT4_ORD = { - eqlType: 'eql_v3.int4_ord', +export const INTEGER_ORD = { + eqlType: 'public.integer_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -export const INT2 = { - eqlType: 'eql_v3.int2', +export const SMALLINT = { + eqlType: 'public.smallint', castAs: 'number', capabilities: STORAGE_ONLY, } as const -export const INT2_EQ = { - eqlType: 'eql_v3.int2_eq', +export const SMALLINT_EQ = { + eqlType: 'public.smallint_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const -export const INT2_ORD_ORE = { - eqlType: 'eql_v3.int2_ord_ore', +export const SMALLINT_ORD_ORE = { + eqlType: 'public.smallint_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -export const INT2_ORD = { - eqlType: 'eql_v3.int2_ord', +export const SMALLINT_ORD = { + eqlType: 'public.smallint_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -// NOTE: int8 (bigint) 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 INT8/INT8_EQ/INT8_ORD_ORE/INT8_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', + eqlType: 'public.date', castAs: 'date', capabilities: STORAGE_ONLY, } as const export const DATE_EQ = { - eqlType: 'eql_v3.date_eq', + eqlType: 'public.date_eq', castAs: 'date', capabilities: EQUALITY_ONLY, } as const export const DATE_ORD_ORE = { - eqlType: 'eql_v3.date_ord_ore', + eqlType: 'public.date_ord_ore', castAs: 'date', capabilities: ORDER_AND_RANGE, } as const export const DATE_ORD = { - eqlType: 'eql_v3.date_ord', + eqlType: 'public.date_ord', castAs: 'date', capabilities: ORDER_AND_RANGE, } as const export const TIMESTAMP = { - eqlType: 'eql_v3.timestamp', + eqlType: 'public.timestamp', castAs: 'timestamp', capabilities: STORAGE_ONLY, } as const export const TIMESTAMP_EQ = { - eqlType: 'eql_v3.timestamp_eq', + eqlType: 'public.timestamp_eq', castAs: 'timestamp', capabilities: EQUALITY_ONLY, } as const export const TIMESTAMP_ORD_ORE = { - eqlType: 'eql_v3.timestamp_ord_ore', + eqlType: 'public.timestamp_ord_ore', castAs: 'timestamp', capabilities: ORDER_AND_RANGE, } as const export const TIMESTAMP_ORD = { - eqlType: 'eql_v3.timestamp_ord', + eqlType: 'public.timestamp_ord', castAs: 'timestamp', capabilities: ORDER_AND_RANGE, } as const export const NUMERIC = { - eqlType: 'eql_v3.numeric', + eqlType: 'public.numeric', castAs: 'number', capabilities: STORAGE_ONLY, } as const export const NUMERIC_EQ = { - eqlType: 'eql_v3.numeric_eq', + eqlType: 'public.numeric_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const export const NUMERIC_ORD_ORE = { - eqlType: 'eql_v3.numeric_ord_ore', + eqlType: 'public.numeric_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const NUMERIC_ORD = { - eqlType: 'eql_v3.numeric_ord', + eqlType: 'public.numeric_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const export const TEXT = { - eqlType: 'eql_v3.text', + eqlType: 'public.text', castAs: 'string', capabilities: STORAGE_ONLY, } as const export const TEXT_EQ = { - eqlType: 'eql_v3.text_eq', + eqlType: 'public.text_eq', castAs: 'string', capabilities: EQUALITY_ONLY, } as const export const TEXT_MATCH = { - eqlType: 'eql_v3.text_match', + eqlType: 'public.text_match', castAs: 'string', capabilities: MATCH_ONLY, } as const export const TEXT_ORD_ORE = { - eqlType: 'eql_v3.text_ord_ore', + eqlType: 'public.text_ord_ore', castAs: 'string', capabilities: ORDER_AND_RANGE, } as const export const TEXT_ORD = { - eqlType: 'eql_v3.text_ord', + eqlType: 'public.text_ord', castAs: 'string', capabilities: ORDER_AND_RANGE, } as const -export const BOOL = { - eqlType: 'eql_v3.bool', +export const BOOLEAN = { + eqlType: 'public.boolean', castAs: 'boolean', capabilities: STORAGE_ONLY, } as const -export const FLOAT4 = { - eqlType: 'eql_v3.float4', +export const REAL = { + eqlType: 'public.real', castAs: 'number', capabilities: STORAGE_ONLY, } as const -export const FLOAT4_EQ = { - eqlType: 'eql_v3.float4_eq', +export const REAL_EQ = { + eqlType: 'public.real_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const -export const FLOAT4_ORD_ORE = { - eqlType: 'eql_v3.float4_ord_ore', +export const REAL_ORD_ORE = { + eqlType: 'public.real_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -export const FLOAT4_ORD = { - eqlType: 'eql_v3.float4_ord', +export const REAL_ORD = { + eqlType: 'public.real_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -export const FLOAT8 = { - eqlType: 'eql_v3.float8', +export const DOUBLE = { + eqlType: 'public.double', castAs: 'number', capabilities: STORAGE_ONLY, } as const -export const FLOAT8_EQ = { - eqlType: 'eql_v3.float8_eq', +export const DOUBLE_EQ = { + eqlType: 'public.double_eq', castAs: 'number', capabilities: EQUALITY_ONLY, } as const -export const FLOAT8_ORD_ORE = { - eqlType: 'eql_v3.float8_ord_ore', +export const DOUBLE_ORD_ORE = { + eqlType: 'public.double_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const -export const FLOAT8_ORD = { - eqlType: 'eql_v3.float8_ord', +export const DOUBLE_ORD = { + eqlType: 'public.double_ord', castAs: 'number', capabilities: ORDER_AND_RANGE, } as const @@ -303,7 +296,7 @@ export const FLOAT8_ORD = { * * - `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 + * HMAC-based — the `public.text_ord` / `public.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 @@ -353,7 +346,7 @@ function isQueryableCapabilities(capabilities: QueryCapabilities): boolean { * 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. `EncryptedBoolColumn` and + * two otherwise-empty subclasses (e.g. `EncryptedBooleanColumn` and * `EncryptedDateColumn`, both storage-only) are NOT mutually assignable. This * nominality is what keeps plaintext inference precise. */ @@ -403,7 +396,7 @@ const TEXT_SEARCH_DOMAIN = { } as const /** - * Builder for an `eql_v3.text_search` column. + * Builder for a `public.text_search` column. * * The concrete type inherently enables equality + order/range + free-text * match — there are no capability-enabling methods. `.freeTextSearch(opts?)` @@ -478,29 +471,31 @@ export class EncryptedTextSearchColumn extends EncryptedV3Column< // distinct domains nominally incompatible. // --------------------------------------------------------------------------- -// int4 -export class EncryptedInt4Column extends EncryptedV3Column {} -export class EncryptedInt4EqColumn extends EncryptedV3Column {} -export class EncryptedInt4OrdOreColumn extends EncryptedV3Column< - typeof INT4_ORD_ORE +// integer +export class EncryptedIntegerColumn extends EncryptedV3Column {} +export class EncryptedIntegerEqColumn extends EncryptedV3Column< + typeof INTEGER_EQ +> {} +export class EncryptedIntegerOrdOreColumn extends EncryptedV3Column< + typeof INTEGER_ORD_ORE > {} -export class EncryptedInt4OrdColumn extends EncryptedV3Column< - typeof INT4_ORD +export class EncryptedIntegerOrdColumn extends EncryptedV3Column< + typeof INTEGER_ORD > {} -// int2 -export class EncryptedInt2Column extends EncryptedV3Column {} -export class EncryptedInt2EqColumn extends EncryptedV3Column {} -export class EncryptedInt2OrdOreColumn extends EncryptedV3Column< - typeof INT2_ORD_ORE +// smallint +export class EncryptedSmallintColumn extends EncryptedV3Column< + typeof SMALLINT > {} -export class EncryptedInt2OrdColumn extends EncryptedV3Column< - typeof INT2_ORD +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 > {} - -// int8 (bigint) domain builders are intentionally omitted pending FFI support -// for lossless bigint round-tripping — see the note by the INT4/DATE domain -// definitions above. // date export class EncryptedDateColumn extends EncryptedV3Column {} @@ -551,31 +546,29 @@ export class EncryptedTextOrdColumn extends EncryptedV3Column< typeof TEXT_ORD > {} -// bool -export class EncryptedBoolColumn extends EncryptedV3Column {} +// boolean +export class EncryptedBooleanColumn extends EncryptedV3Column {} -// float4 -export class EncryptedFloat4Column extends EncryptedV3Column {} -export class EncryptedFloat4EqColumn extends EncryptedV3Column< - typeof FLOAT4_EQ -> {} -export class EncryptedFloat4OrdOreColumn extends EncryptedV3Column< - typeof FLOAT4_ORD_ORE +// real +export class EncryptedRealColumn extends EncryptedV3Column {} +export class EncryptedRealEqColumn extends EncryptedV3Column {} +export class EncryptedRealOrdOreColumn extends EncryptedV3Column< + typeof REAL_ORD_ORE > {} -export class EncryptedFloat4OrdColumn extends EncryptedV3Column< - typeof FLOAT4_ORD +export class EncryptedRealOrdColumn extends EncryptedV3Column< + typeof REAL_ORD > {} -// float8 -export class EncryptedFloat8Column extends EncryptedV3Column {} -export class EncryptedFloat8EqColumn extends EncryptedV3Column< - typeof FLOAT8_EQ +// double +export class EncryptedDoubleColumn extends EncryptedV3Column {} +export class EncryptedDoubleEqColumn extends EncryptedV3Column< + typeof DOUBLE_EQ > {} -export class EncryptedFloat8OrdOreColumn extends EncryptedV3Column< - typeof FLOAT8_ORD_ORE +export class EncryptedDoubleOrdOreColumn extends EncryptedV3Column< + typeof DOUBLE_ORD_ORE > {} -export class EncryptedFloat8OrdColumn extends EncryptedV3Column< - typeof FLOAT8_ORD +export class EncryptedDoubleOrdColumn extends EncryptedV3Column< + typeof DOUBLE_ORD > {} /** @@ -583,14 +576,14 @@ export class EncryptedFloat8OrdColumn extends EncryptedV3Column< * columns so a table may mix any generated domains. */ export type AnyEncryptedV3Column = - | EncryptedInt4Column - | EncryptedInt4EqColumn - | EncryptedInt4OrdOreColumn - | EncryptedInt4OrdColumn - | EncryptedInt2Column - | EncryptedInt2EqColumn - | EncryptedInt2OrdOreColumn - | EncryptedInt2OrdColumn + | EncryptedIntegerColumn + | EncryptedIntegerEqColumn + | EncryptedIntegerOrdOreColumn + | EncryptedIntegerOrdColumn + | EncryptedSmallintColumn + | EncryptedSmallintEqColumn + | EncryptedSmallintOrdOreColumn + | EncryptedSmallintOrdColumn | EncryptedDateColumn | EncryptedDateEqColumn | EncryptedDateOrdOreColumn @@ -609,15 +602,15 @@ export type AnyEncryptedV3Column = | EncryptedTextOrdOreColumn | EncryptedTextOrdColumn | EncryptedTextSearchColumn - | EncryptedBoolColumn - | EncryptedFloat4Column - | EncryptedFloat4EqColumn - | EncryptedFloat4OrdOreColumn - | EncryptedFloat4OrdColumn - | EncryptedFloat8Column - | EncryptedFloat8EqColumn - | EncryptedFloat8OrdOreColumn - | EncryptedFloat8OrdColumn + | EncryptedBooleanColumn + | EncryptedRealColumn + | EncryptedRealEqColumn + | EncryptedRealOrdOreColumn + | EncryptedRealOrdColumn + | EncryptedDoubleColumn + | EncryptedDoubleEqColumn + | EncryptedDoubleOrdOreColumn + | EncryptedDoubleOrdColumn /** * Shape of v3 table columns: every value is a v3 concrete column builder. diff --git a/packages/stack/src/eql/v3/index.ts b/packages/stack/src/eql/v3/index.ts index 417b2f6d..31702c59 100644 --- a/packages/stack/src/eql/v3/index.ts +++ b/packages/stack/src/eql/v3/index.ts @@ -3,7 +3,7 @@ // 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 (`INT4`, `TEXT_EQ`, …) — those are +// NOT re-export the per-domain literal consts (`INTEGER`, `TEXT_EQ`, …) — those are // internal building blocks for `types` — and there are no standalone // `encryptedColumn` factories any more: `types.*` is the single // authoring API. @@ -18,31 +18,31 @@ export type { } from './columns' export { - EncryptedBoolColumn, + EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, EncryptedDateOrdColumn, EncryptedDateOrdOreColumn, - EncryptedFloat4Column, - EncryptedFloat4EqColumn, - EncryptedFloat4OrdColumn, - EncryptedFloat4OrdOreColumn, - EncryptedFloat8Column, - EncryptedFloat8EqColumn, - EncryptedFloat8OrdColumn, - EncryptedFloat8OrdOreColumn, - EncryptedInt2Column, - EncryptedInt2EqColumn, - EncryptedInt2OrdColumn, - EncryptedInt2OrdOreColumn, - EncryptedInt4Column, - EncryptedInt4EqColumn, - EncryptedInt4OrdColumn, - EncryptedInt4OrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, EncryptedNumericColumn, EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, diff --git a/packages/stack/src/eql/v3/types.ts b/packages/stack/src/eql/v3/types.ts index b8f4ed13..4fcd3b4e 100644 --- a/packages/stack/src/eql/v3/types.ts +++ b/packages/stack/src/eql/v3/types.ts @@ -1,34 +1,38 @@ import { - BOOL, + BOOLEAN, DATE, DATE_EQ, DATE_ORD, DATE_ORD_ORE, - EncryptedBoolColumn, + DOUBLE, + DOUBLE_EQ, + DOUBLE_ORD, + DOUBLE_ORD_ORE, + EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, EncryptedDateOrdColumn, EncryptedDateOrdOreColumn, - EncryptedFloat4Column, - EncryptedFloat4EqColumn, - EncryptedFloat4OrdColumn, - EncryptedFloat4OrdOreColumn, - EncryptedFloat8Column, - EncryptedFloat8EqColumn, - EncryptedFloat8OrdColumn, - EncryptedFloat8OrdOreColumn, - EncryptedInt2Column, - EncryptedInt2EqColumn, - EncryptedInt2OrdColumn, - EncryptedInt2OrdOreColumn, - EncryptedInt4Column, - EncryptedInt4EqColumn, - EncryptedInt4OrdColumn, - EncryptedInt4OrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, EncryptedNumericColumn, EncryptedNumericEqColumn, EncryptedNumericOrdColumn, EncryptedNumericOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, EncryptedTextColumn, EncryptedTextEqColumn, EncryptedTextMatchColumn, @@ -39,26 +43,22 @@ import { EncryptedTimestampEqColumn, EncryptedTimestampOrdColumn, EncryptedTimestampOrdOreColumn, - FLOAT4, - FLOAT4_EQ, - FLOAT4_ORD, - FLOAT4_ORD_ORE, - FLOAT8, - FLOAT8_EQ, - FLOAT8_ORD, - FLOAT8_ORD_ORE, - INT2, - INT2_EQ, - INT2_ORD, - INT2_ORD_ORE, - INT4, - INT4_EQ, - INT4_ORD, - INT4_ORD_ORE, + INTEGER, + INTEGER_EQ, + INTEGER_ORD, + INTEGER_ORD_ORE, NUMERIC, NUMERIC_EQ, NUMERIC_ORD, NUMERIC_ORD_ORE, + REAL, + REAL_EQ, + REAL_ORD, + REAL_ORD_ORE, + SMALLINT, + SMALLINT_EQ, + SMALLINT_ORD, + SMALLINT_ORD_ORE, TEXT, TEXT_EQ, TEXT_MATCH, @@ -71,11 +71,15 @@ import { } 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.` domain - * (strip the `eql_v3.` prefix, PascalCase each `_`-separated segment). So - * `types.TextEq('actor')` builds an `eql_v3.text_eq` column, `types.Int4Ord` - * an `eql_v3.int4_ord`, `types.Timestamp` an `eql_v3.timestamp`, and so on. + * The v3 column-type namespace. Each member is a public, semantic factory name + * for a concrete EQL v3 column. Most members mirror the underlying domain name; + * JS-friendly scalar names map to Postgres concrete domains, e.g. + * `types.IntegerOrd` builds a `public.integer_ord` column and `types.Boolean` + * builds a `public.boolean` column. + * + * If these factory names stop matching the emitted capability/domain surface, + * the stack package is out of sync with the underlying EQL build. That is a + * version mismatch, not a harmless naming drift. * * Each factory returns the CONCRETE column class instance (never the widened * `AnyEncryptedV3Column`) so per-column plaintext / query-capability inference @@ -86,30 +90,32 @@ import { * * const events = encryptedTable('events', { * actor: types.TextEq('actor'), // equality - * weight: types.Int4Ord('weight'), // order + range + * 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). int8/bigint domains are intentionally absent pending lossless FFI - * round-tripping (see ./columns). + * type). */ export const types = { - // int4 - Int4: (name: string) => new EncryptedInt4Column(name, INT4), - Int4Eq: (name: string) => new EncryptedInt4EqColumn(name, INT4_EQ), - Int4OrdOre: (name: string) => - new EncryptedInt4OrdOreColumn(name, INT4_ORD_ORE), - Int4Ord: (name: string) => new EncryptedInt4OrdColumn(name, INT4_ORD), + // 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), - // int2 - Int2: (name: string) => new EncryptedInt2Column(name, INT2), - Int2Eq: (name: string) => new EncryptedInt2EqColumn(name, INT2_EQ), - Int2OrdOre: (name: string) => - new EncryptedInt2OrdOreColumn(name, INT2_ORD_ORE), - Int2Ord: (name: string) => new EncryptedInt2OrdColumn(name, INT2_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), @@ -144,20 +150,20 @@ export const types = { TextOrd: (name: string) => new EncryptedTextOrdColumn(name, TEXT_ORD), TextSearch: (name: string) => new EncryptedTextSearchColumn(name), - // bool - Bool: (name: string) => new EncryptedBoolColumn(name, BOOL), + // boolean + Boolean: (name: string) => new EncryptedBooleanColumn(name, BOOLEAN), - // float4 - Float4: (name: string) => new EncryptedFloat4Column(name, FLOAT4), - Float4Eq: (name: string) => new EncryptedFloat4EqColumn(name, FLOAT4_EQ), - Float4OrdOre: (name: string) => - new EncryptedFloat4OrdOreColumn(name, FLOAT4_ORD_ORE), - Float4Ord: (name: string) => new EncryptedFloat4OrdColumn(name, FLOAT4_ORD), + // 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), - // float8 - Float8: (name: string) => new EncryptedFloat8Column(name, FLOAT8), - Float8Eq: (name: string) => new EncryptedFloat8EqColumn(name, FLOAT8_EQ), - Float8OrdOre: (name: string) => - new EncryptedFloat8OrdOreColumn(name, FLOAT8_ORD_ORE), - Float8Ord: (name: string) => new EncryptedFloat8OrdColumn(name, FLOAT8_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/types.ts b/packages/stack/src/types.ts index f530b59d..5a3cca00 100644 --- a/packages/stack/src/types.ts +++ b/packages/stack/src/types.ts @@ -1,7 +1,9 @@ import type { AuthStrategy, Encrypted as CipherStashEncrypted, + EncryptedPayload as CipherStashEncryptedPayload, EncryptedQuery as CipherStashEncryptedQuery, + EncryptedV3Query as CipherStashEncryptedV3Query, JsPlaintext, newClient, QueryOpName, @@ -49,18 +51,22 @@ export type Client = Awaited> | undefined export type EncryptedValue = Brand /** 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 and + * the EQL v3 payloads. 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 + * 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 +export type EncryptedQuery = + | CipherStashEncryptedQuery + | CipherStashEncryptedV3Query /** * Plaintext values the SDK accepts for encryption. @@ -68,17 +74,11 @@ export type EncryptedQuery = CipherStashEncryptedQuery * Widens the FFI's `JsPlaintext` (`string | number | boolean | * Record | 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. + * 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`. + * When the upstream FFI `JsPlaintext` includes `Date`, this extra arm can + * collapse back into `JsPlaintext`. */ export type Plaintext = JsPlaintext | Date @@ -147,6 +147,17 @@ export type ClientConfig = { * @see {@link AuthStrategy} */ strategy?: AuthStrategy + + /** + * The EQL wire-format version the client encrypts to. Defaults to `2` + * (protect-ffi's own default when omitted). v3 concrete-type schemas MUST + * use `3` — the {@link EncryptionV3} factory sets this automatically, so you + * normally never set it by hand. A mismatch (a `3` client with v2 schemas, + * or a `2` client with v3 concrete-type columns) makes the FFI's per-column + * domain resolution fail every encrypt with "Cannot convert undefined or + * null to object". + */ + eqlVersion?: 2 | 3 } type AtLeastOneCsTable = [T, ...T[]] diff --git a/packages/stack/vitest.config.ts b/packages/stack/vitest.config.ts index c4b1da04..f27fc47c 100644 --- a/packages/stack/vitest.config.ts +++ b/packages/stack/vitest.config.ts @@ -21,6 +21,17 @@ export default defineConfig({ }, }, test: { + // Live suites make real ZeroKMS / CTS network round-trips. The vast + // majority of these tests already pass an explicit `, 30000)` per-test + // timeout (300+ call sites); a handful were written without one and so + // fell back to Vitest's 5000ms default. Under the default forks pool with + // file parallelism, many live suites hit ZeroKMS concurrently and those + // 5000ms-default tests intermittently time out (they pass in isolation). + // Align the global default with the dominant explicit value so the intent + // is uniform. 30s is comfortably above real network latency but still low + // enough to surface a genuine hang. + testTimeout: 30000, + hookTimeout: 30000, 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 diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index a2d4c85b..0d237f5d 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.28.0 + version: 0.28.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) @@ -944,8 +944,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.28.0': + resolution: {integrity: sha512-QRwiovEdgjstbaCONZGYXA82NG4Gwz9mJOZeAzthUmNIQfnVErO9UQAfJ+I1T/YG1Ww2FCWcHltXMl/qjyeK4A==} cpu: [arm64] os: [darwin] @@ -954,8 +954,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.28.0': + resolution: {integrity: sha512-H8qB2z3drJSc2bR5ITsJSFrOoNKvORbauTdHmaS1e5OleXsLl/F+56Zvghz8NWs+bXs/2aVzHxpYte8FgV8AAQ==} cpu: [x64] os: [darwin] @@ -964,8 +964,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.28.0': + resolution: {integrity: sha512-h7vZxB/wako6j1jspkGl41gptTN1dBTWYqAR6jhVnvKJK0TBlyUKuSJwO1NeqyNfFQ/b1KmqJ11JGvY95uRZOA==} cpu: [arm64] os: [linux] @@ -974,8 +974,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.28.0': + resolution: {integrity: sha512-PgHn0Og0PiCwFdV4yKhipGKfqkCXP6Xchyy6ykTaISabmSlkkbRNkyNF1/tZEQYF65sm5gmqSpwSYzKODaAsbg==} cpu: [x64] os: [linux] @@ -984,8 +984,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.28.0': + resolution: {integrity: sha512-fMu3k1Y3wYMcGbGpVtrlCMNRLd1//5c9ZHcyWFjKFqimOCbBO5akgCQij4zcvj4kYDHtveu9dOdOKVhaG8k6hQ==} cpu: [x64] os: [linux] @@ -994,16 +994,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.28.0': + resolution: {integrity: sha512-tF0y7TcyBtgN/jHodYMnrJ4etLkEI/klzDivW8Q8eIuIdoJ3q5muZKFIhNX0MbDDdh2O4GsRdNhXRubs7BiFpA==} 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.28.0': + resolution: {integrity: sha512-R2L/8HwMREkVKlR5KCcuELIWz4QNButSBQzY+nRDHl1PUXjRqWG1h265FkKVtTXKNKUup7rB4mswu+M+t9KF3A==} '@clack/core@1.3.0': resolution: {integrity: sha512-xJPHpAmEQUBrXSLx0gF+q5K/IyihXpsHZcha+jB+tyahsKRK3Dxo4D0coZDewHo12NhiuzC3dTtMPbm53GEAAA==} @@ -4443,37 +4443,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.28.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.28.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.28.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.28.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.28.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.28.0': optional: true '@cipherstash/protect-ffi@0.23.0': @@ -4487,16 +4487,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.28.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.28.0 + '@cipherstash/protect-ffi-darwin-x64': 0.28.0 + '@cipherstash/protect-ffi-linux-arm64-gnu': 0.28.0 + '@cipherstash/protect-ffi-linux-x64-gnu': 0.28.0 + '@cipherstash/protect-ffi-linux-x64-musl': 0.28.0 + '@cipherstash/protect-ffi-win32-x64-msvc': 0.28.0 '@clack/core@1.3.0': dependencies: