diff --git a/.changeset/eql-v3-text-search.md b/.changeset/eql-v3-text-search.md new file mode 100644 index 00000000..41cff5d3 --- /dev/null +++ b/.changeset/eql-v3-text-search.md @@ -0,0 +1,14 @@ +--- +"@cipherstash/stack": minor +--- + +Add the EQL v3 `text_search` authoring DSL on a new `@cipherstash/stack/schema/v3` +subpath (`encryptedTextSearchColumn`, v3 `encryptedTable` / `buildEncryptConfig`). +The v3 builders emit the existing `EncryptConfig` shape, so encryption, payloads, +and query paths are unchanged at runtime. + +Also widens the public client types (`EncryptionClientConfig.schemas`, +`EncryptOptions`, `SearchTerm`/`EncryptQueryOptions`) to a structural contract so +both v2 and v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / +`encryptQuery`. This is a backward-compatible widening — existing v2 usage is +unaffected. diff --git a/.changeset/eql-v3-typed-client.md b/.changeset/eql-v3-typed-client.md new file mode 100644 index 00000000..39cd0e38 --- /dev/null +++ b/.changeset/eql-v3-typed-client.md @@ -0,0 +1,29 @@ +--- +"@cipherstash/stack": minor +--- + +Add a strongly-typed EQL v3 client surface on a new `@cipherstash/stack/v3` +subpath (`EncryptionV3`, `typedClient`, `TypedEncryptionClient`). It re-exports +the v3 schema builders, so a single import provides everything needed to author +and use a v3 schema. + +Every method derives its types from the concrete `table` / `column` builder +arguments: + +- `encrypt` / `encryptQuery` pin the plaintext to the column's domain type + (`text → string`, `int8 → bigint`, `timestamptz → Date`, …). +- `encryptQuery` constrains `queryType` to the column's capabilities and rejects + storage-only columns at compile time. +- `encryptModel` / `bulkEncryptModels` validate schema-column fields against their + inferred plaintext type (passthrough fields are untouched) and return a precise + encrypted model. +- `decryptModel` / `bulkDecryptModels` return the precise plaintext model, + reconstructing `Date` / `bigint` values from the encrypt-config `cast_as`. + +Because the typed methods bind to the concrete branded v3 classes, a hand-rolled +structural table/column is rejected — closing the soundness gap where a non-branded +table could be encrypted at runtime while typed as plaintext. + +Runtime behaviour is unchanged: the encrypt/query paths return the same operations +as the base client; only the model-decrypt paths add a per-column `Date` / `bigint` +reconstruction step. The v2 client surface (`Encryption`) is untouched. diff --git a/.changeset/eql-v3-typed-schema.md b/.changeset/eql-v3-typed-schema.md new file mode 100644 index 00000000..464054fb --- /dev/null +++ b/.changeset/eql-v3-typed-schema.md @@ -0,0 +1,7 @@ +--- +'@cipherstash/stack': minor +--- + +Add EQL v3 schema builders for all generated SQL domains under `@cipherstash/stack/schema/v3`, including explicit query capability metadata (`getQueryCapabilities()` / `isQueryable()`) and v3 table support in model encryption helpers (`encryptModel` / `bulkEncryptModels`). + +Also widen the accepted plaintext input type for `encrypt` / `encryptQuery` to include `Date` and `bigint` (via the new `Plaintext` type), so v3 `date` / `timestamptz` / `int8` domains can be encrypted and queried with their natural JavaScript values. diff --git a/.github/workflows/fta-v3.yml b/.github/workflows/fta-v3.yml new file mode 100644 index 00000000..3ee52b01 --- /dev/null +++ b/.github/workflows/fta-v3.yml @@ -0,0 +1,60 @@ +name: "FTA Complexity (EQL v3)" + +# Blocking complexity gate for the EQL v3 text-search schema. Runs the Fast +# TypeScript Analyzer (fta-cli) against the v3 source directory only and fails +# the check when any file exceeds the score cap (`--score-cap` in the +# `analyze:complexity` script). FTA is pure static source analysis, so this job +# needs no build step, database, or credentials. + +on: + push: + branches: + - 'main' + paths: + - 'packages/stack/src/schema/v3/**' + - 'packages/stack/package.json' + - '.github/workflows/fta-v3.yml' + pull_request: + branches: + - "**" + paths: + - 'packages/stack/src/schema/v3/**' + - 'packages/stack/package.json' + - '.github/workflows/fta-v3.yml' + +permissions: + contents: read + +jobs: + fta: + name: Analyze v3 complexity + runs-on: blacksmith-4vcpu-ubuntu-2404 + + steps: + - name: Checkout Repo + uses: actions/checkout@v6 + + - uses: pnpm/action-setup@v6.0.8 + name: Install pnpm + with: + run_install: false + + - name: Install Node.js + uses: actions/setup-node@v6 + with: + node-version: 22 + cache: 'pnpm' + + # node-pty's install hook falls back to `node-gyp rebuild` when no + # linux-x64 prebuild matches. pnpm/action-setup v6 no longer ships + # node-gyp on PATH, so install it explicitly. + - name: Install node-gyp + run: npm install -g node-gyp + + - name: Install dependencies + run: pnpm install --frozen-lockfile + + # Non-zero exit (score above the cap) fails the check — this is the + # blocking gate. No `continue-on-error`. + - name: Analyze v3 complexity + run: pnpm --filter @cipherstash/stack run analyze:complexity diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 26b874b6..2cbc2592 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -59,6 +59,9 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + - name: Type tests (stack) + run: pnpm --filter @cipherstash/stack run test:types + - name: Lint — no hardcoded package-manager runners run: pnpm run lint:runners diff --git a/docs/query-api-walkthrough.md b/docs/query-api-walkthrough.md new file mode 100644 index 00000000..8559a2ed --- /dev/null +++ b/docs/query-api-walkthrough.md @@ -0,0 +1,77 @@ +# Query API Walkthrough — API → FFI → CipherStash Client + +How a query value travels from the public API down to the Rust SDK across the FFI boundary. Terse by design. + +## Flow + +```mermaid +flowchart TD + subgraph JS["@cipherstash/stack (TypeScript)"] + A["User query builder
ops.eq / Supabase filter / client.encryptQuery()"] + B["EncryptionClient.encryptQuery(value | terms[])
encryption/index.ts:259"] + C["EncryptQueryOperation.execute()
BatchEncryptQueryOperation.execute()"] + D["resolveIndexType() + queryTypeToFfi/QueryOp
build QueryPayload{plaintext,column,table,indexType,queryOp}"] + E["validate: validateNumericValue
assertValueIndexCompatibility"] + end + + subgraph FFI["@cipherstash/protect-ffi (Neon bindings)"] + F["JS wrapper encryptQuery / encryptQueryBulk
lib/index.cjs:155"] + G["native handle via @neon-rs/load
lib/load.cjs:9"] + H["platform .node addon
protect-ffi-darwin-arm64/index.node"] + end + + subgraph RUST["CipherStash Client (Rust SDK)"] + I["EQL term generation
ORE / match / unique / ste_vec"] + J["ZeroKMS key ops"] + end + + A --> B --> C --> E --> D --> F --> G --> H --> I + I --> J + I -- "Encrypted | EncryptedQuery" --> F + F -- "formatEncryptedResult()" --> C + C -- "SQL/PostgREST WHERE clause" --> A +``` + +## Layers + +| # | Layer | Entry point | Role | +|---|-------|-------------|------| +| 1 | Public API | `encryption/index.ts:259/270` `encryptQuery()` | Overloaded: single value → `EncryptQueryOperation`; `ScalarQueryTerm[]` → `BatchEncryptQueryOperation`. | +| 1a | Query builders | `drizzle/operators.ts:976`, `supabase/query-builder.ts:44` | `eq/gt/...` operators & deferred builders that batch-encrypt RHS values, then emit a WHERE clause. | +| 2 | Operations | `operations/encrypt-query.ts:41`, `operations/batch-encrypt-query.ts:115` | `execute()`: validate → resolve index → call FFI. `*WithLockContext` resolves `LockContextInput` via `resolveLockContext` before the FFI call. | +| 3 | EQL resolution | `helpers/infer-index-type.ts:89`, `types.ts:292` | `resolveIndexType` + `queryTypeToFfi`/`queryTypeToQueryOp` map public `QueryTypeName` → FFI `indexType`/`queryOp`. | +| 4 | FFI JS wrapper | `protect-ffi/lib/index.cjs:155` | `encryptQuery`/`encryptQueryBulk` → `wrapAsync(native.*)`. | +| 5 | Native loader | `protect-ffi/lib/load.cjs:9` | `@neon-rs/load` proxies to the platform prebuilt `.node`. | +| 6 | Rust SDK | compiled into `.node` | CipherStash Client: encryption, EQL/ORE/STE-vec term gen, ZeroKMS. Not a JS dep — shipped inside the addon. | + +## Query-type mapping (Layer 3) + +```mermaid +flowchart LR + subgraph Public["QueryTypeName"] + eq[equality] + ord[orderAndRange] + txt[freeTextSearch] + sel[steVecSelector] + trm[steVecTerm] + end + subgraph FFI["indexType / queryOp"] + u[unique] + o[ore] + m[match] + sv[ste_vec] + end + eq --> u + ord --> o + txt --> m + sel --> sv + trm --> sv +``` + +## Notes + +- **Client init:** `EncryptionClient.init()` (`encryption/index.ts:81`) calls FFI `newClient()` once; the returned `Client` handle is passed into every `encryptQuery` call. +- **`cipherstashclient`** = the CipherStash Client **Rust SDK**, compiled via Neon into the platform `.node` binary inside `@cipherstash/protect-ffi`. It performs the actual crypto and talks to ZeroKMS. +- **Result shape:** `EncryptedQueryResult` (`types.ts:175`); shaped by `formatEncryptedResult(..., returnType)` (`eql` vs raw). +- **Version:** `package.json` pins `@cipherstash/protect-ffi@0.24.0` (installed tree observed at `0.23.0` — confirm before relying on it). +- `packages/protect/src/ffi/*` mirrors this flow under the older `protect` package name. diff --git a/docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md b/docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md new file mode 100644 index 00000000..6df325f4 --- /dev/null +++ b/docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md @@ -0,0 +1,1211 @@ +# EQL v3 `text_search` Schema DSL Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add an EQL v3 authoring DSL (`encryptedTextSearchColumn`, plus v3 `encryptedTable` / `buildEncryptConfig`) on a new `@cipherstash/stack/schema/v3` subpath that emits the existing `EncryptConfig` shape with zero native-client changes. + +**Architecture:** A new, self-contained module at `packages/stack/src/schema/v3/index.ts` mirrors the v2 builder structure but exposes one concrete type — `EncryptedTextSearchColumn` — whose capabilities (equality + order/range + free-text match) are baked in. Its `build()` returns the **same** `ColumnSchema` a fully-configured v2 column produces, so the encryption client, payload, and query paths are untouched. The v2 module (`src/schema/index.ts`) is not modified. + +**Tech Stack:** TypeScript (ES2022, bundler module resolution), Zod 3.25.76, Vitest 3, tsup (dual ESM+CJS build), Biome (formatting/lint). + +## Review dispositions + +Code-review feedback verified against the actual files before incorporation. Verdicts and what changed: + +- **[VALID] `token_filters: []` nullish-merge edge is untested.** Confirmed `[] ?? x` evaluates to `[]` (an empty array is not nullish), so an explicit `token_filters: []` DOES override the downcase default through the `?? ` merge. v2 tests this (`schema-builders.test.ts:87-103` passes `token_filters: []` and asserts `[]` survives). The v3 plan's override test (Task 1, Step 1) deliberately omitted `token_filters` and never exercised the explicit-empty-array path. **Change:** added a dedicated `.freeTextSearch({ token_filters: [] })` override test asserting `match.token_filters === []`. +- **[VALID] Repeated `.freeTextSearch()` calls are untested.** Confirmed the sketched v3 `freeTextSearch()` (like v2 `src/schema/index.ts:353-367`) re-merges each call against a fresh defaults object (`defaultMatchOpts()` after the batch-2 factory change), NOT against current state — so `.freeTextSearch({ k: 8 }).freeTextSearch({ m: 4096 })` resets `k` back to `6` (last-call-wins-fully). This matches v2 exactly, so per the "mirror v2 exactly" global constraint we KEEP this behavior rather than switching to merge-against-current (which would diverge from v2). **Change:** added a repeated-call test that pins the v2-consistent last-call-wins-fully semantics. +- **[VALID] Type-level tests don't run in CI (pre-existing repo issue).** Confirmed `vitest.config.ts` has no `typecheck` block, `package.json` `test` script is `vitest run` (no `--typecheck`), and `.github/workflows/tests.yml` runs `pnpm run test`. Vitest only collects `*.test-d.ts` under typecheck mode, so the existing `__tests__/types.test-d.ts` is ALSO unenforced in CI today. **Change:** added Task 4, Step 4 — add a `test:types` package script. (Batch 2 finalizes the CI decision: scope typecheck + wire into CI — see below.) +- **[VALID] Dead-code remap in `InferPlaintext`/`InferEncrypted`.** In v3's flat single-type model `EncryptedV3TableColumn = { [key: string]: EncryptedTextSearchColumn }`, the `as C[K] extends EncryptedTextSearchColumn ? K : never` key-remap filters nothing (every value is already that type). v2 needs the filter because its column map also admits nested-object branches (`src/schema/index.ts:526`, `548`). **Change:** simplified both helpers to `{ [K in keyof C]: string }` / `{ [K in keyof C]: Encrypted }` with a comment marking the filter as a future extension point for when more v3 concrete types land. +- **[VALID] API surface bloat: three ways to read one literal.** v2 exposes column metadata via methods only (`getName()`, `build()` — no getters: `src/schema/index.ts:240-407`). The plan exposed the eql type via a `get eqlType` getter AND `getEqlType()` AND an exported const. **Change (partial):** dropped the `get eqlType` property getter; kept `getEqlType()` (method, matching v2 convention) and the exported `TEXT_SEARCH_EQL_TYPE` const (the single source-of-truth literal, useful for external comparison without instantiation). Updated the constraint, the interface list, and the test that asserted `col.eqlType`. +- **[VALID] Assertions.** **Changes:** switched the load-bearing/default `build()` assertions to `toStrictEqual` (catches stray `undefined` keys); switched the two column-instance type checks from the looser `toMatchTypeOf` to `toEqualTypeOf`; added a negative `@ts-expect-error` type test proving a v2 `EncryptedColumn` is rejected by the v3 `EncryptedV3TableColumn` constraint (v2/v3 column classes carry different private fields, so they are nominally non-assignable — the rejection is real). +- **[VALID] Type tightening.** **Changes:** tightened `InferPlaintext`/`InferEncrypted` constraints from `EncryptedTable` to `EncryptedTable`; inlined the pointless `const castAs: CastAs = 'string'` local into `cast_as: 'string'` (the `ColumnSchema` return type already checks the literal against `CastAs`), and dropped the now-unused `CastAs` import. + +### Batch 2 — scope decision + further review + +**SCOPE DECISION (Option A): v3 must WORK with the client.** This increment now includes widening the public client types so the v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / `encryptQuery`. Verified the runtime path is purely structural — no `instanceof` anywhere in `src/encryption/operations/*.ts`; the client only reads `column.getName()` (`encrypt.ts:53` etc.), `column.build()` (`encryption/helpers/infer-index-type.ts:11,58`), `table.tableName` (`encrypt.ts:52` etc.), `table.build().columns` (`encryption/helpers/model-helpers.ts:268,566`; dynamodb ops), and `buildEncryptConfig(...schemas)` which calls `tb.build()` (`encryption/index.ts:674`). The blocking types are in `src/types.ts`: `EncryptionClientConfig.schemas` (:98), `EncryptOptions.column`/`table` (:113-114), `SearchTerm` (:123-128) / `QueryTermBase` (:275-280) `.column`/`.table` — all typed against nominal v2 classes (private fields → v3 class not assignable). **Added Task 5** to widen these to a structural contract; runtime is untouched. + +- **[VALID — real latent bug] Shared mutable defaults.** Confirmed in the plan's sketch: `this.matchOpts = { ...DEFAULT_MATCH_OPTS }` is a SHALLOW copy, so the module-level `DEFAULT_MATCH_OPTS.tokenizer` and `.token_filters` (and the `{ kind: 'downcase' }` object inside) are shared by reference across every column built from defaults; `.freeTextSearch()` re-uses those same refs on the `?? ` fallback; and `build()` returns `this.matchOpts` directly. So a caller mutating one built config can mutate the shared defaults used by later columns (cross-column aliasing). **v2 comparison:** v2 (`src/schema/index.ts:353-367`) constructs FRESH inline object literals each `freeTextSearch()` call (no shared module-level const), so it has no cross-column aliasing — but its `build()` still returns `this.indexesValue` by reference, a milder self-aliasing latent issue. Not fixing v2 here. **Change (Task 1):** replaced the `DEFAULT_MATCH_OPTS` const with a `defaultMatchOpts()` factory (fresh nested objects per call) and made `build()` return a deep-cloned `match` block; added a two-column independent-mutation test. +- **[VALID] Missing changeset.** Confirmed the repo uses Changesets (`.changeset/config.json`, sample `.changeset/native-binary-guards.md`). Frontmatter key is the package `name`; `packages/stack/package.json` name is `@cipherstash/stack`. **Change: added Task 6** to create a `.changeset/*.md` with a **minor** bump (additive `./schema/v3` subpath + exports, plus backward-compatible type widening). +- **[VALID] Task 4 TDD label.** "Write the failing type test" contradicted "run to verify it passes" — these type tests are expected green on first run. **Change:** renamed Task 4 Step 1 to "Write type-level regression tests" and adjusted the surrounding wording so the sequencing is honest. +- **[CI — scoped path chosen, with finding] Enforce v3 type tests in CI.** Ran `pnpm exec vitest --run --typecheck __tests__/types.test-d.ts`: the `types.test-d.ts` assertions PASS (18 passed, "Type Errors: no errors"), but the package-wide typecheck surfaces **124 pre-existing "Unhandled Source Error"s** — `src/wasm-inline.ts` can't resolve `@cipherstash/auth/wasm-inline` / `@cipherstash/protect-ffi/wasm-inline` type decls, plus a type mismatch in `__tests__/wasm-inline-normalize.test.ts:69`. Root cause: `tsconfig.json` has NO `include`, so typecheck checks every file. Verified `@/encryption` does NOT import `wasm-inline.ts`, so a typecheck program rooted only at the `*.test-d.ts` files (which import `@/schema`, `@/schema/v3`, `@/types`, `@/encryption`) will not reach the broken modules. **Decision (per coordinator's "scope safely"):** SCOPE Vitest typecheck to the stack package's type-test files via a dedicated narrow `tsconfig.typecheck.json`, add a `test:types` script, and wire THAT into CI — so v3 (and the existing) type tests are enforced without forcing a repo-wide cleanup. The 124 latent wasm-inline typecheck errors are recorded as a flagged follow-up, NOT fixed here. (See Task 4 — scoped config/script in Steps 2-3, CI wiring in Step 5; flag refined in Batch 3 below.) + +### Batch 3 — widen internal consumers + tighten typecheck scoping + +- **[VALID — real gap] Task 5 widened only the public aliases, not the internal consumers.** Verified that widening `EncryptOptions` / `SearchTerm` / `QueryTermBase` to `BuildableColumn` / `BuildableTable` breaks internal code that stores those values into narrow v2-typed fields. Concretely: `operations/encrypt.ts` declares `private column: EncryptedColumn | EncryptedField` (:27) / `private table: EncryptedTable` (:28), assigns `opts.column`/`opts.table` into them (:38-39), and re-exposes them via `getOperation()` (:112-113); `operations/bulk-encrypt.ts` has the same fields (:66-67) plus the module-level `createEncryptPayloads(column: EncryptedColumn | EncryptedField, table: EncryptedTable)` (:28-29); `helpers/infer-index-type.ts` types `inferIndexType` (:10), `validateIndexType` (:55), `resolveIndexType` (:87) as `column: EncryptedColumn` and they are called with the now-widened `term.column` / `opts.column`. **Verified the contract is sufficient (no over-widening / no richer contract needed):** every one of these consumers only ever calls `.getName()`, `.tableName`, and `column.build().indexes` — all present on `BuildableColumn` / `BuildableTable` (`build(): ColumnSchema` exposes `.indexes`). **Verified NOT affected (so we don't over-reach):** `EncryptionClient` stores only `client` + `encryptConfig` (no narrow `schemas` field; methods pass `opts` straight to the operation constructors at `index.ts:203,575,298`), so no client-field change; `operations/encrypt-query.ts` / `batch-encrypt-query.ts` store the *public* widened types (`EncryptQueryOptions` / `ScalarQueryTerm[]`) with no narrow re-declaration, so they need no edit; and the MODEL path (`encrypt-model.ts`, `bulk-encrypt-models.ts`, `model-helpers.ts`) stays narrow (`EncryptedTable` / `EncryptedTable`) because the generic model methods are intentionally NOT widened — so those files are untouched. **Change:** expanded Task 5's file list + steps to also widen `operations/encrypt.ts`, `operations/bulk-encrypt.ts`, and `helpers/infer-index-type.ts` (each with the exact fields/signatures + line refs), with an explicit "do NOT widen the model path" guard. +- **[VALID] `test:types` could run runtime suites.** `vitest --run --typecheck` enables typecheck but still runs the runtime suites too (including credential/network-sensitive ones). Verified the repo's Vitest is **3.2.4** (`package.json` `"vitest": "catalog:repo"` → `3.2.4`), which supports `--typecheck.only`. **Change:** `test:types` is now `vitest --run --typecheck.only` (typecheck enabled, runtime suites skipped), with `tsconfig`/`include` set in `vitest.config.ts`; CI calls the same script. +- **[VALID] First typecheck run was unscoped.** Task 4's old Step 2 ran `vitest --run --typecheck __tests__/schema-v3.test-d.ts` BEFORE the scoped `tsconfig.typecheck.json` existed (created in the old Step 4), so the very first run would hit the 124 unrelated errors. **Change:** reordered Task 4 so the scoped `tsconfig.typecheck.json` + `vitest.config.ts` `typecheck` block + `test:types` script are created FIRST (new Step 2); every typecheck invocation (Task 4 and Task 5's failing-first run) goes through `pnpm run test:types`, which is scoped from the very first run. +- **[VALID] Duplicate `Encrypted` import.** Task 4 Step 1 already adds `import type { Encrypted } from '@/types'`; Task 5 Step 1 repeated it. **Change:** Task 5 now adds ONLY the genuinely new imports (`Encryption, EncryptionClient` from `@/encryption`; `encryptedTable as v2EncryptedTable` extending the existing `@/schema` import) and reuses the already-imported `Encrypted`. + +### Batch 4 — split the query column contract (encryptQuery must reject non-queryable fields) + +- **[VALID — type-safety regression in batch-2/3 widening] `encryptQuery` was widened too far.** Batch 2 widened `SearchTerm.column` / `QueryTermBase.column` from the nominal `EncryptedColumn` to the structural `BuildableColumn`. Verified the problem: `BuildableColumn` (`{ getName(): string; build(): ColumnSchema }`) is INTENTIONALLY also satisfied by v2 `EncryptedField` (confirmed `EncryptedField` at `src/schema/index.ts:197` has `getName()` (:235) and `build()` returning `{ cast_as, indexes: {} }` (:228)) — that structural match is REQUIRED so `encrypt()` can still target nested fields. Side effect: widening the query path to `BuildableColumn` would make `encryptQuery()` type-callable with an `encryptedField(...)`, which has no indexes and which the original nominal `EncryptedColumn` correctly rejected; it would only blow up at runtime ("no indexes configured"). **Fix:** keep `encrypt`'s storage path at `BuildableColumn` (columns AND fields), but give the query path its own narrower contract `BuildableQueryColumn = EncryptedColumn | (BuildableColumn & { getEqlType(): string })`. Verified `getEqlType()` is a sound discriminator: a `grep` for `getEqlType` across `src/` returns nothing today (v3 not implemented), v2 `EncryptedColumn`/`EncryptedField` do NOT declare it, and only v3 `EncryptedTextSearchColumn` will — so the nominal arm admits v2 queryable columns, the structural arm admits v3 queryable columns, and `EncryptedField` (no `getEqlType`, not an `EncryptedColumn`) is excluded. Verified the narrowing is safe for the storage path: the `infer-index-type.ts` functions batch-3 widened (`inferIndexType`/`validateIndexType`/`resolveIndexType`) are reached ONLY via `resolveIndexType`, imported solely by `operations/encrypt-query.ts` (:72,:165) and `operations/batch-encrypt-query.ts` (:51) — NOT by `encrypt.ts`/`bulk-encrypt.ts` — so narrowing them to `BuildableQueryColumn` cannot break field encryption. **Change:** `SearchTerm.column` + `QueryTermBase.column` → `BuildableQueryColumn`; `EncryptOptions.column` stays `BuildableColumn`; the three `infer-index-type.ts` signatures take `BuildableQueryColumn` (not `BuildableColumn`); added negative (`encryptQuery` rejects a field) + positive (`encrypt` accepts a field; `encryptQuery` accepts v2 column and v3 column) type tests. + - **Follow-up flagged (not blocking):** `getEqlType()` works as the queryability discriminator only because the sole v3 type shipping is `text_search`, which is queryable. If a future v3 *non-queryable* concrete type also carries `getEqlType()`, the structural arm would wrongly admit it. When such a type lands, switch the discriminator to a queryability-specific marker (e.g. a `readonly __queryable` brand or an explicit capability method) rather than the generic `getEqlType()`. Kept `getEqlType()` for now. + +### Batch 5 — pin the bulk-encrypt widen-site + note the WASM v3 boundary + +- **[VALID — should-fix] `bulk-encrypt.ts` widen-site was vague + mislabeled.** The batch-3 step covered the `column`/`table` re-exposure only via a conditional ("if the `*WithLockContext` variant re-exposes … widen those too") with no line ref and the wrong owning class. Verified the real site: it is `BulkEncryptOperation.getOperation()`'s RETURN TYPE at `src/encryption/operations/bulk-encrypt.ts:141-142` (`column: EncryptedColumn | EncryptedField` (:141), `table: EncryptedTable` (:142)) — destructured and consumed by `BulkEncryptOperationWithLockContext.execute()` at :168 (uses only `.getName()` / `.tableName`). It is NOT a member of the `*WithLockContext` class. **Change:** rewrote the `bulk-encrypt.ts` step to pin `:141-142` as a REQUIRED widen-site on `BulkEncryptOperation.getOperation()`, with the corrected class label, so an implementer can't leave `bulk-encrypt.ts` red. +- **[VALID — flag, not blocking] WASM-inline path does not accept v3 columns.** Verified `src/wasm-inline.ts:314-320`: `getColumnName(col: EncryptOptions['column'])` does `if (col instanceof EncryptedColumn || col instanceof EncryptedField) return col.getName(); throw …`. Confirmed (a) it STILL type-checks after the `EncryptOptions['column']` widening — an `instanceof` guard narrowing a wider union is valid TS; and (b) it is OUTSIDE the scoped typecheck graph (`@/encryption` doesn't import `wasm-inline.ts`; the `test:types` tsconfig roots only the `*.test-d.ts` files), so it does NOT make the package red. But a v3 column routed through the WASM-inline entry would hit the `else throw` at RUNTIME. This is consistent with the batch-2 "no `instanceof`" finding being explicitly scoped to `operations/*.ts`. **Change:** added a note to Task 5 (Step 3b) and the spec's known-boundaries that the WASM-inline entry does not yet accept v3 columns — a deferred, documented boundary, not a latent surprise. + +### Batch 6 — `Required` vs an explicit built type + +- **[REFUTED as a bug → applied as robustness] `Required` could fail typecheck.** The finding claimed that because `matchIndexOptsSchema` fields are `.default(...).optional()` (`src/schema/index.ts:99-105`), `Required<>` might not strip `undefined` and the plan's `defaultMatchOpts()` / `matchOpts` spread-clone could fail declaration/build typecheck. **Verified and refuted under this repo's actual config:** + - `tsconfig.json` sets `strict: true`, has **no `extends`** (no base tsconfig), and does **NOT** set `exactOptionalPropertyTypes`. + - TS's `-?` mapped modifier (`Required = { [K]-?: T[K] }`) DOES strip `undefined` when `exactOptionalPropertyTypes` is off. Reproduced empirically with the repo's TypeScript **5.9.3**: a faithful replica of the plan's exact pattern (`Required` factory + private field + the `build()` spread/clone of `tokenizer`/`token_filters` + `.map()` + non-`undefined` assignments) compiles with **ZERO errors** under `--strict` (no EOPT). It only errors (TS2532 / TS2322) when `--exactOptionalPropertyTypes` is forced on — which the repo does not use. + - **v2 precedent confirms it:** v2 already declares `match?: Required` (`src/schema/index.ts:246`, not `:247` — `:247` is `ste_vec`) and the package builds/ships under this tsconfig. So `Required` works in-repo today; the "can fail typecheck" premise is false here. + - **Decision (robustness, NOT a fix):** still adopted `BuiltMatchIndexOpts` (`{ tokenizer: NonNullable; … }`) for `defaultMatchOpts()`'s return type and the private `matchOpts` field, because it states non-null intent explicitly and is decoupled from `Required<>`'s `exactOptionalPropertyTypes`-dependent subtlety. Verified empirically that this explicit type compiles clean BOTH without AND with `exactOptionalPropertyTypes` (so it also future-proofs the new module against a later strictness bump, which `Required` would not survive). The public tuning input stays `MatchIndexOpts` (all-optional); only the internal resolved shape uses `BuiltMatchIndexOpts`. The emitted `build()` shape is unchanged (a fully-required object is assignable to the optional `ColumnSchema.indexes.match`). + +### Batch 7 — `@ts-expect-error` placement in the Batch-4 negative test + +- **[VALID — real defect] Batch-4 negative test placed `@ts-expect-error` on the wrong line.** The Batch-4 test put `// @ts-expect-error` directly above the `client.encryptQuery('…', {` call line, but the `EncryptedField`-not-assignable-to-`BuildableQueryColumn` error is a DEEP object-literal property mismatch that tsc reports on the inner `column:` argument line, not the call's first line. Since `@ts-expect-error` only suppresses the immediately-following line, the directive would be unused → **TS2578 "Unused '@ts-expect-error' directive"** AND the real error would leak from the `column:` line → `schema-v3.test-d.ts` goes red. (Hazard compounded: an implementer "fixing" the TS2578 by deleting the directive would silently delete the negative guarantee.) **Reproduced empirically** with the repo's TypeScript **5.9.3**: directive-above-the-call → TS2578 (at the directive line) + TS2741 (at the `column:` line); directive-directly-above-`column:` (multi-line) or a collapsed one-line call → both clean (no TS2578, no leak). **Fix (Variant B):** moved the `@ts-expect-error` to sit directly above the `column: v2usersWithField.profile.email,` line (kept the call multi-line), matching the placement style of Task 4's negative test, and added an inline comment explaining the deep-property-line requirement. +- **Audit of all other `@ts-expect-error` directives in the plan:** the only other one is Task 4's "rejects a v2 `EncryptedColumn` in a v3 table" test — verified it ALREADY sits directly above the offending `email: encryptedColumn('email'),` property line (the generic-constraint mismatch lands there), so it is correctly placed and needs no change. No other mis-placed directives found. + +## Global Constraints + +- **Do NOT change** the v2 module's (`packages/stack/src/schema/index.ts`) runtime behavior or the shape of its existing exported symbols. The DSL additions are purely additive. The ONLY permitted edit to this file is a backward-compatible **widening** of `buildEncryptConfig`'s parameter type to the shared structural `BuildableTable` contract (Task 5) — a pure widening (existing callers still type-check) required so the client accepts both v2 and v3 tables. (If the team prefers zero v2 edits, the documented fallback in Task 5 is to assemble the config inline in `Encryption()` instead.) +- **Runtime is structural and unchanged.** The encrypt/decrypt/query path reads only `column.getName()`, `column.build()`, `table.tableName`, `table.build().columns` — no `instanceof`. Client integration is achieved by widening the public TYPES (Task 5), not by a runtime rewrite. +- v3 builders MUST emit the existing `ColumnSchema` / `EncryptConfig` shape imported from `@/schema` — reuse the v2 types, do not redefine them. +- `cast_as` MUST be the SDK-facing literal `'string'` (NOT `'text'`). `toEqlCastAs` is a v2/wasm-inline concern and is out of scope here. +- Match-index defaults MUST mirror the v2 `freeTextSearch()` builder **exactly**: `tokenizer: { kind: 'ngram', token_length: 3 }`, `token_filters: [{ kind: 'downcase' }]`, `k: 6`, `m: 2048`, `include_original: true`. (Note: `include_original` is `true` — the v2 builder default, not the zod-schema default of `false`.) +- `unique.token_filters` defaults to `[]` (case-sensitive equality, matching v2). +- `.freeTextSearch(opts?)` is **tuning only** — it overrides match-index params and NEVER enables a capability. Merge semantics are per-top-level-key replace against the defaults (mirror v2's `opts?.x ?? default`). +- `EncryptedTextSearchColumn` records the eql type `'eql_v3.text_search'`, exposed via the `getEqlType()` method ONLY (no property getter — methods-not-getters matches the v2 builder convention). The single source-of-truth literal is the exported `TEXT_SEARCH_EQL_TYPE` const. This value is metadata for future increments and MUST be absent from `build()` output. +- v3 `encryptedTable` and `buildEncryptConfig` intentionally shadow the v2 symbol names; they live only on the `/v3` subpath. `buildEncryptConfig` emits `{ v: 1, tables }`. +- Tests live in `packages/stack/__tests__/`, named `*.test.ts` (runtime) and `*.test-d.ts` (type-level, run via the scoped `test:types` script with `--typecheck.only` — Task 4). Source imports use the `@/` alias (`@/schema`, `@/schema/v3`, `@/types`). +- Run all commands from `packages/stack/` unless noted. The test runner is `pnpm exec vitest`. +- Keep changes Biome-clean (2-space indent, single quotes, no semicolons — match the surrounding files). + +## File Structure + +- **Create:** `packages/stack/src/schema/v3/index.ts` — the entire v3 DSL: `EncryptedTextSearchColumn`, v3 `EncryptedTable`, `encryptedTextSearchColumn`, `encryptedTable`, `buildEncryptConfig`, `InferPlaintext`, `InferEncrypted`, and the `EncryptedV3TableColumn` shape type. Single focused file (the spec allows splitting later if it grows). +- **Create:** `packages/stack/__tests__/schema-v3.test.ts` — runtime behavior tests. +- **Create:** `packages/stack/__tests__/schema-v3.test-d.ts` — type-level inference tests. +- **Modify:** `packages/stack/tsup.config.ts` — add `src/schema/v3/index.ts` to the main config's `entry` array. +- **Modify:** `packages/stack/package.json` — add the `./schema/v3` export, `typesVersions` entry, and a `test:types` script. +- **Modify:** `packages/stack/src/types.ts` — define the structural `BuildableColumn` / `BuildableTable` contract and widen `EncryptionClientConfig.schemas`, `EncryptOptions`, `SearchTerm` / `QueryTermBase` to it (Task 5). +- **Modify:** `packages/stack/src/schema/index.ts` — backward-compatible widening of `buildEncryptConfig`'s parameter type ONLY (Task 5; see Global Constraints for the fallback). +- **Modify:** `packages/stack/src/encryption/operations/encrypt.ts`, `.../operations/bulk-encrypt.ts` (storage path → `BuildableColumn` / `BuildableTable`) and `.../helpers/infer-index-type.ts` (query path → `BuildableQueryColumn`) — widen the internal consumers of the widened public types (Task 5, Step 3b). +- **Create:** `packages/stack/tsconfig.typecheck.json` — narrow tsconfig (roots = `__tests__/**/*.test-d.ts`) so Vitest typecheck enforces the type tests without dragging in the 124 pre-existing wasm-inline errors (Task 4). +- **Modify:** `packages/stack/vitest.config.ts` — add a `typecheck` block (include `__tests__/**/*.test-d.ts`, `tsconfig: './tsconfig.typecheck.json'`) (Task 4). +- **Modify:** `.github/workflows/tests.yml` — run the scoped type tests in CI (Task 4). +- **Create:** `.changeset/.md` — minor bump for `@cipherstash/stack` (Task 6). + +--- + +### Task 1: `EncryptedTextSearchColumn` builder + +**Files:** +- Create: `packages/stack/src/schema/v3/index.ts` +- Test: `packages/stack/__tests__/schema-v3.test.ts` + +**Interfaces:** +- Consumes (from v2, `@/schema`): `type ColumnSchema`, `type MatchIndexOpts`, the runtime builder `encryptedColumn` (test only, for the equivalence assertion). (`CastAs` is NOT consumed — `build()` emits the bare `'string'` literal, checked by the `ColumnSchema` return type.) +- Produces: + - `class EncryptedTextSearchColumn` with: + - `constructor(columnName: string)` + - `freeTextSearch(opts?: MatchIndexOpts): this` + - `build(): ColumnSchema` + - `getName(): string` + - `getEqlType(): 'eql_v3.text_search'` (method only — no `get eqlType` property getter) + - `function encryptedTextSearchColumn(columnName: string): EncryptedTextSearchColumn` + - `const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search'` (exported const literal) + +- [ ] **Step 1: Write the failing tests** + +Create `packages/stack/__tests__/schema-v3.test.ts`: + +```ts +import { describe, expect, it } from 'vitest' +import { encryptedColumn } from '@/schema' +import { + EncryptedTextSearchColumn, + encryptedTextSearchColumn, +} from '@/schema/v3' + +describe('eql_v3 text_search column', () => { + it('returns an EncryptedTextSearchColumn with the correct name', () => { + const col = encryptedTextSearchColumn('email') + expect(col).toBeInstanceOf(EncryptedTextSearchColumn) + expect(col.getName()).toBe('email') + }) + + it('.build() emits the pinned default config (cast_as: string + all three indexes)', () => { + const built = encryptedTextSearchColumn('email').build() + // toStrictEqual (not toEqual) so a stray `undefined` key would fail. + expect(built).toStrictEqual({ + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }) + }) + + it('LOAD-BEARING: default build() deep-equals the v2 equality+order+match column', () => { + const v3 = encryptedTextSearchColumn('email').build() + const v2 = encryptedColumn('email') + .equality() + .orderAndRange() + .freeTextSearch() + .build() + // toStrictEqual: byte-identical, no extra/undefined keys on either side. + expect(v3).toStrictEqual(v2) + }) + + it('.freeTextSearch(opts) overrides each provided key and keeps the rest as defaults', () => { + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + k: 8, + m: 4096, + include_original: false, + }) + .build() + expect(built.indexes.match).toEqual({ + tokenizer: { kind: 'ngram', token_length: 4 }, + // omitted -> default downcase filter retained + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }) + }) + + it('.freeTextSearch({ token_filters: [] }) overrides the downcase default with an empty array', () => { + // LOAD-BEARING: `[] ?? default` evaluates to `[]` (an empty array is not + // nullish), so an explicit empty array must OVERRIDE the downcase default, + // not fall back to it. Mirrors v2 (schema-builders.test.ts). + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ token_filters: [] }) + .build() + expect(built.indexes.match.token_filters).toEqual([]) + }) + + it('repeated .freeTextSearch() calls are last-call-wins-fully (each re-merges against defaults, not prior state)', () => { + // Each call re-merges against a fresh defaultMatchOpts(), not the + // accumulated matchOpts — so the second call resets k back to its default + // of 6. This is intentional: it mirrors v2 exactly. Pinned here so a future + // "merge against current state" change can't silently slip in. + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ k: 8 }) + .freeTextSearch({ m: 4096 }) + .build() + expect(built.indexes.match.k).toBe(6) + expect(built.indexes.match.m).toBe(4096) + }) + + it('.freeTextSearch() is tuning-only: unique and ore indexes stay present', () => { + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ k: 8 }) + .build() + expect(built.indexes.unique).toEqual({ token_filters: [] }) + expect(built.indexes.ore).toEqual({}) + }) + + it('getEqlType() returns the concrete domain name', () => { + const col = encryptedTextSearchColumn('email') + expect(col.getEqlType()).toBe('eql_v3.text_search') + }) + + it('eqlType metadata is absent from build() output', () => { + const built = encryptedTextSearchColumn('email').build() + expect(built).not.toHaveProperty('eqlType') + expect(Object.keys(built).sort()).toEqual(['cast_as', 'indexes']) + }) + + it('built columns share no mutable state: mutating one build() output does not affect another', () => { + // Guards against the shared-defaults aliasing bug: defaults come from a + // per-instance factory and build() deep-clones the match block. + const a = encryptedTextSearchColumn('a').build() + const b = encryptedTextSearchColumn('b').build() + + // Mutate every nested level of a's match block. + a.indexes.match.k = 999 + a.indexes.match.token_filters.push({ kind: 'downcase' }) + a.indexes.match.tokenizer = { kind: 'standard' } + + expect(b.indexes.match.k).toBe(6) + expect(b.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + expect(b.indexes.match.tokenizer).toEqual({ kind: 'ngram', token_length: 3 }) + + // A second build() of an independent column is also pristine. + const c = encryptedTextSearchColumn('c').build() + expect(c.indexes.match.k).toBe(6) + expect(c.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) +}) +``` + +- [ ] **Step 2: Run the tests to verify they fail** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: FAIL — module resolution error `Failed to resolve import "@/schema/v3"` (the file does not exist yet). + +- [ ] **Step 3: Create the v3 module with the column builder** + +Create `packages/stack/src/schema/v3/index.ts`: + +```ts +import type { ColumnSchema, MatchIndexOpts } from '@/schema' + +/** + * The concrete EQL v3 domain name for a full-capability text column. + * Recorded as metadata for future DDL / query-dialect increments; it is + * intentionally absent from the emitted encrypt config. + */ +export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' + +/** + * Fully-resolved match-index options: every field present and non-`undefined`. + * + * `MatchIndexOpts` (the user-facing tuning input) has all fields optional — + * each is `.default(...).optional()` in the zod schema, so its inferred type is + * `T | undefined`. This type pins the BUILT/resolved shape explicitly via + * `NonNullable<...>`, which states the non-null intent directly and is robust + * regardless of `Required<>`'s subtle, `exactOptionalPropertyTypes`-dependent + * stripping semantics. (v2 uses `Required` and that compiles + * fine under this repo's tsconfig — `strict: true`, NO `exactOptionalPropertyTypes` + * — so this is a clarity/robustness choice, not a fix for a present break.) + */ +type BuiltMatchIndexOpts = { + tokenizer: NonNullable + token_filters: NonNullable + k: NonNullable + m: NonNullable + include_original: NonNullable +} + +/** + * Default match-index parameters. These mirror the v2 `freeTextSearch()` + * builder defaults EXACTLY (note `include_original: true`, which is the v2 + * builder default rather than the zod-schema default of `false`). + * + * This is a FACTORY (not a shared `const`) so every caller gets fresh, unaliased + * nested objects (`tokenizer`, `token_filters` and the `{ kind: 'downcase' }` + * inside it). A shared const would be shallow-copied by `{ ...DEFAULT }`, leaving + * those nested objects aliased across every column — a caller mutating one built + * config could then corrupt the defaults used by later columns. + */ +function defaultMatchOpts(): BuiltMatchIndexOpts { + return { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + } +} + +/** + * Builder for an `eql_v3.text_search` column. + * + * The concrete type inherently enables equality + order/range + free-text + * match — there are no capability-enabling methods. `.freeTextSearch(opts?)` + * tunes the match index only. + */ +export class EncryptedTextSearchColumn { + private readonly columnName: string + private matchOpts: BuiltMatchIndexOpts + + constructor(columnName: string) { + this.columnName = columnName + this.matchOpts = defaultMatchOpts() + } + + /** + * The concrete EQL v3 domain name. Metadata only; not emitted by `build()`. + * Method (not a property getter) to match the v2 builder convention. + */ + getEqlType(): typeof TEXT_SEARCH_EQL_TYPE { + return TEXT_SEARCH_EQL_TYPE + } + + /** + * Tune the match index. Each provided key replaces its default; omitted + * keys keep the default. This NEVER enables a capability — match is always + * on for this type. Merge semantics mirror v2's `opts?.x ?? default`. + */ + freeTextSearch(opts?: MatchIndexOpts): this { + // A fresh defaults object per call supplies the `?? ` fallbacks, so no + // nested default object is ever shared into `this.matchOpts` by reference. + const defaults = defaultMatchOpts() + this.matchOpts = { + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + } + return this + } + + /** Emit the encrypt-config column. Byte-identical to a v2 equality+order+match column. */ + build(): ColumnSchema { + // `cast_as` is typed `CastAs` by the `ColumnSchema` return type, so the + // literal is checked here without a redundant local annotation. + // + // Deep-clone the match block so the returned config NEVER aliases this + // builder's internal `matchOpts` (or any caller-supplied opts merged into + // it). A caller mutating the returned object cannot corrupt this builder's + // state or another column's defaults. + return { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + ...this.matchOpts, + tokenizer: { ...this.matchOpts.tokenizer }, + token_filters: this.matchOpts.token_filters.map((f) => ({ ...f })), + }, + }, + } + } + + getName(): string { + return this.columnName + } +} + +/** + * Define an `eql_v3.text_search` column. The concrete type carries all three + * capabilities (equality + order/range + free-text match). Chain + * `.freeTextSearch(opts)` to tune the match index. + */ +export function encryptedTextSearchColumn( + columnName: string, +): EncryptedTextSearchColumn { + return new EncryptedTextSearchColumn(columnName) +} +``` + +- [ ] **Step 4: Run the tests to verify they pass** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: PASS (all 10 tests in this describe block green). + +- [ ] **Step 5: Commit** + +```bash +git add packages/stack/src/schema/v3/index.ts packages/stack/__tests__/schema-v3.test.ts +git commit -m "feat(stack): add eql_v3 text_search column builder" +``` + +--- + +### Task 2: v3 `encryptedTable`, `buildEncryptConfig`, and inference helpers + +**Files:** +- Modify: `packages/stack/src/schema/v3/index.ts` (append table + config + inference) +- Test: `packages/stack/__tests__/schema-v3.test.ts` (append `describe` blocks) + +**Interfaces:** +- Consumes (from v2, `@/schema`): `type ColumnSchema`, `type EncryptConfig`, `encryptConfigSchema` (test only). From `@/types`: `type Encrypted`. +- Consumes (from Task 1): `EncryptedTextSearchColumn`, `encryptedTextSearchColumn`. +- Produces: + - `type EncryptedV3TableColumn = { [key: string]: EncryptedTextSearchColumn }` + - `class EncryptedTable` with `tableName: string`, `columnBuilders: T`, and `build(): { tableName: string; columns: Record }` + - `function encryptedTable(tableName: string, columns: T): EncryptedTable & T` + - `function buildEncryptConfig(...tables: Array>): EncryptConfig` + - `type InferPlaintext>` → `{ [col]: string }` + - `type InferEncrypted>` → `{ [col]: Encrypted }` + +- [ ] **Step 1: Write the failing tests** + +Append to `packages/stack/__tests__/schema-v3.test.ts`. First add `encryptConfigSchema` to the existing `@/schema` import and the table symbols to the `@/schema/v3` import, so the file header becomes: + +```ts +import { describe, expect, it } from 'vitest' +import { encryptConfigSchema, encryptedColumn } from '@/schema' +import { + buildEncryptConfig, + EncryptedTable, + EncryptedTextSearchColumn, + encryptedTable, + encryptedTextSearchColumn, +} from '@/schema/v3' +``` + +Then append these `describe` blocks at the end of the file: + +```ts +describe('eql_v3 encryptedTable', () => { + it('creates a table exposing column builders as properties', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + expect(users).toBeInstanceOf(EncryptedTable) + expect(users.tableName).toBe('users') + expect(users.email).toBeInstanceOf(EncryptedTextSearchColumn) + }) + + it('table.email returns the same builder instance passed in', () => { + const emailCol = encryptedTextSearchColumn('email') + const users = encryptedTable('users', { email: emailCol }) + expect(users.email).toBe(emailCol) + }) + + it('build() assembles { tableName, columns } with built column configs', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const built = users.build() + expect(built.tableName).toBe('users') + expect(built.columns).toStrictEqual({ + email: { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }, + }) + }) +}) + +describe('eql_v3 buildEncryptConfig', () => { + it('produces a { v: 1, tables } config', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const config = buildEncryptConfig(users) + expect(config.v).toBe(1) + expect(config.tables).toHaveProperty('users') + expect(config.tables.users).toHaveProperty('email') + }) + + it('emits a config that passes encryptConfigSchema.parse()', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const config = buildEncryptConfig(users) + expect(() => encryptConfigSchema.parse(config)).not.toThrow() + }) + + it('supports multiple tables', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const posts = encryptedTable('posts', { + body: encryptedTextSearchColumn('body'), + }) + const config = buildEncryptConfig(users, posts) + expect(Object.keys(config.tables).sort()).toEqual(['posts', 'users']) + }) +}) +``` + +- [ ] **Step 2: Run the tests to verify they fail** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: FAIL — `buildEncryptConfig`, `EncryptedTable`, and `encryptedTable` are not exported from `@/schema/v3` (import errors / `is not a function`). + +- [ ] **Step 3: Append the table, config builder, and inference helpers** + +Append to `packages/stack/src/schema/v3/index.ts`. First extend the import at the top of the file so it reads: + +```ts +import type { + ColumnSchema, + EncryptConfig, + MatchIndexOpts, +} from '@/schema' +import type { Encrypted } from '@/types' +``` + +Then append after `encryptedTextSearchColumn`: + +```ts +/** + * Shape of v3 table columns: every value is a top-level + * {@link EncryptedTextSearchColumn}. (Nested fields and other v3 concrete + * types are deferred to later increments.) + */ +export type EncryptedV3TableColumn = { + [key: string]: EncryptedTextSearchColumn +} + +interface TableDefinition { + tableName: string + columns: Record +} + +/** + * A v3 encrypted table. Mirrors the v2 `EncryptedTable` but only accepts v3 + * column builders. Emits the same `{ tableName, columns }` definition shape. + */ +export class EncryptedTable { + /** @internal Type-level brand so TypeScript can infer `T` from `EncryptedTable`. */ + declare readonly _columnType: T + + constructor( + public readonly tableName: string, + public readonly columnBuilders: T, + ) {} + + build(): TableDefinition { + const builtColumns: Record = {} + for (const [colName, builder] of Object.entries(this.columnBuilders)) { + builtColumns[colName] = builder.build() + } + return { + tableName: this.tableName, + columns: builtColumns, + } + } +} + +/** + * Define a v3 encrypted table. Intentionally shadows the v2 `encryptedTable` + * name but lives on the `/v3` subpath — the importer picks the model by import + * path. The returned object is also a column accessor (`users.email`). + */ +export function encryptedTable( + tableName: string, + columns: T, +): EncryptedTable & T { + const tableBuilder = new EncryptedTable( + tableName, + columns, + ) as EncryptedTable & T + + for (const [colName, colBuilder] of Object.entries(columns)) { + ;(tableBuilder as EncryptedV3TableColumn)[colName] = colBuilder + } + + return tableBuilder +} + +/** + * Build an `EncryptConfig` (`v: 1`) from one or more v3 tables. Emits the same + * shape as v2's `buildEncryptConfig`. + */ +export function buildEncryptConfig( + ...tables: Array> +): EncryptConfig { + const config: EncryptConfig = { + v: 1, + tables: {}, + } + + for (const tb of tables) { + const tableDef = tb.build() + config.tables[tableDef.tableName] = tableDef.columns + } + + return config +} + +/** + * Infer the plaintext (decrypted) shape from a v3 table schema. + * + * In v3's flat single-type column model every value is an + * {@link EncryptedTextSearchColumn}, so no key-remap filter is needed — every + * column maps to `string`. When future v3 increments add other concrete column + * types (or nested fields), reintroduce a `[K in keyof C as C[K] extends ... ]` + * filter here. + */ +export type InferPlaintext> = + T extends EncryptedTable ? { [K in keyof C]: string } : never + +/** + * Infer the encrypted shape from a v3 table schema. See {@link InferPlaintext} + * for why no key-remap filter is needed in the flat single-type model. + */ +export type InferEncrypted> = + T extends EncryptedTable ? { [K in keyof C]: Encrypted } : never +``` + +Note: `CastAs` is intentionally NOT imported — Task 1's `build()` emits the bare `'string'` literal (checked by the `ColumnSchema` return type), so no `CastAs` annotation is needed anywhere in this module. + +- [ ] **Step 4: Run the tests to verify they pass** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: PASS (all runtime tests across both describe groups green). + +- [ ] **Step 5: Commit** + +```bash +git add packages/stack/src/schema/v3/index.ts packages/stack/__tests__/schema-v3.test.ts +git commit -m "feat(stack): add eql_v3 encryptedTable and buildEncryptConfig" +``` + +--- + +### Task 3: Wire the `./schema/v3` export subpath + +**Files:** +- Modify: `packages/stack/tsup.config.ts` (add the v3 entry) +- Modify: `packages/stack/package.json` (`exports` + `typesVersions`) + +**Interfaces:** +- Consumes: the module from Tasks 1-2 at `src/schema/v3/index.ts`. +- Produces: external import path `@cipherstash/stack/schema/v3` resolving to `dist/schema/v3/index.{js,cjs,d.ts,d.cts}`. + +- [ ] **Step 1: Add the v3 build entry to tsup** + +In `packages/stack/tsup.config.ts`, find the `entry` array of the FIRST (main) config object and add the v3 path. Change: + +```ts + 'src/schema/index.ts', + 'src/drizzle/index.ts', +``` + +to: + +```ts + 'src/schema/index.ts', + 'src/schema/v3/index.ts', + 'src/drizzle/index.ts', +``` + +- [ ] **Step 2: Add the `./schema/v3` export to package.json** + +In `packages/stack/package.json`, in the `exports` object, add a `./schema/v3` entry immediately after the existing `./schema` block: + +```json + "./schema/v3": { + "import": { + "types": "./dist/schema/v3/index.d.ts", + "default": "./dist/schema/v3/index.js" + }, + "require": { + "types": "./dist/schema/v3/index.d.cts", + "default": "./dist/schema/v3/index.cjs" + } + }, +``` + +(Place it between the `./schema` block and the `./types` block. Keep the existing tab indentation used in this file.) + +- [ ] **Step 3: Add the `schema/v3` typesVersions entry** + +In `packages/stack/package.json`, in the `typesVersions["*"]` object, add immediately after the existing `"schema"` entry: + +```json + "schema/v3": [ + "./dist/schema/v3/index.d.ts" + ], +``` + +- [ ] **Step 4: Build and verify the export resolves** + +Run: `pnpm run build` +Expected: build succeeds and emits `dist/schema/v3/index.js`, `dist/schema/v3/index.cjs`, `dist/schema/v3/index.d.ts`, `dist/schema/v3/index.d.cts`. + +Then verify the published export name resolves in both module systems (run from `packages/stack/`): + +```bash +node -e "const m = require('@cipherstash/stack/schema/v3'); if (typeof m.encryptedTextSearchColumn !== 'function') { throw new Error('CJS export missing'); } console.log('cjs ok')" +node --input-type=module -e "import('@cipherstash/stack/schema/v3').then(m => { if (typeof m.encryptedTextSearchColumn !== 'function') throw new Error('ESM export missing'); console.log('esm ok'); })" +``` + +Expected: prints `cjs ok` then `esm ok`. + +- [ ] **Step 5: Run the CJS-consumer regression test** + +The existing `__tests__/cjs-require.test.ts` auto-discovers every `dist/**/*.cjs` entry, so it now also exercises `dist/schema/v3/index.cjs` (no edit needed). + +Run: `pnpm exec vitest run __tests__/cjs-require.test.ts` +Expected: PASS — including the discovered `dist/schema/v3/index.cjs` entry (loads in a real Node CJS process, no externalized ESM-only `require`). + +- [ ] **Step 6: Commit** + +```bash +git add packages/stack/tsup.config.ts packages/stack/package.json +git commit -m "feat(stack): wire @cipherstash/stack/schema/v3 export subpath" +``` + +--- + +### Task 4: Type-level inference tests + CI enforcement + +**Files:** +- Create: `packages/stack/__tests__/schema-v3.test-d.ts` +- Create: `packages/stack/tsconfig.typecheck.json` (Step 4) +- Modify: `packages/stack/vitest.config.ts` (add a scoped `typecheck` block — Step 4) +- Modify: `packages/stack/package.json` (add a `test:types` script — Step 4) +- Modify: `.github/workflows/tests.yml` (run the scoped type tests in CI — Step 4) + +> Note: the v3 client-integration acceptance type-tests (`Encryption({ schemas: [v3users] })`, `client.encrypt`/`decrypt`/`encryptQuery` with v3 builders) are added in **Task 5**, which also appends to this same `schema-v3.test-d.ts`. They are enforced by the same CI wiring set up here. + +**Interfaces:** +- Consumes: `encryptedTable`, `encryptedTextSearchColumn`, `type EncryptedTextSearchColumn`, `type InferEncrypted`, `type InferPlaintext` from `@/schema/v3`; `type Encrypted` from `@/types`; `encryptedColumn` from `@/schema` (v2, for the negative `@ts-expect-error` rejection test). + +- [ ] **Step 1: Write type-level regression tests** + +These are regression/guard tests, expected to type-check green on first run (Tasks 1-2 already define the types they assert). Create `packages/stack/__tests__/schema-v3.test-d.ts`: + +```ts +import { describe, expectTypeOf, it } from 'vitest' +// v2 column builder — used only to prove the v3 table type rejects it. +import { encryptedColumn } from '@/schema' +import type { + EncryptedTextSearchColumn, + InferEncrypted, + InferPlaintext, +} from '@/schema/v3' +import { encryptedTable, encryptedTextSearchColumn } from '@/schema/v3' +import type { Encrypted } from '@/types' + +describe('eql_v3 schema type inference', () => { + it('encryptedTextSearchColumn returns an EncryptedTextSearchColumn', () => { + const col = encryptedTextSearchColumn('email') + expectTypeOf(col).toEqualTypeOf() + }) + + it('encryptedTable exposes column builders as typed properties', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + expectTypeOf(users.email).toEqualTypeOf() + expectTypeOf(users.tableName).toBeString() + }) + + it('rejects a v2 EncryptedColumn in a v3 table (nominal private-field mismatch)', () => { + encryptedTable('users', { + // @ts-expect-error - a v2 EncryptedColumn is not an EncryptedTextSearchColumn + email: encryptedColumn('email'), + }) + }) + + it('InferPlaintext maps each column to string', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + name: encryptedTextSearchColumn('name'), + }) + type Plaintext = InferPlaintext + expectTypeOf().toEqualTypeOf<{ email: string; name: string }>() + }) + + it('InferEncrypted maps each column to Encrypted', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + type Enc = InferEncrypted<typeof users> + expectTypeOf<Enc>().toEqualTypeOf<{ email: Encrypted }>() + }) +}) +``` + +- [ ] **Step 2: Create the SCOPED typecheck config + `test:types` script (BEFORE any typecheck run)** + +`.test-d.ts` files run ONLY in Vitest typecheck mode, and today nothing runs typecheck in CI (`package.json` `test` = `vitest run`; `tests.yml` runs `pnpm run test`). So neither this `schema-v3.test-d.ts` nor the pre-existing `types.test-d.ts` is enforced — a wrong inferred shape would NOT fail the build. + +**Verified finding (do not skip):** `tsconfig.json` has NO `include`, so a naive package-wide `vitest --typecheck` checks every file and surfaces **124 pre-existing "Unhandled Source Error"s** unrelated to v3 — `src/wasm-inline.ts` cannot resolve `@cipherstash/auth/wasm-inline` / `@cipherstash/protect-ffi/wasm-inline` type decls, plus a type mismatch at `__tests__/wasm-inline-normalize.test.ts:69`. (The `*.test-d.ts` assertions themselves pass.) So we set up the SCOPED config FIRST, so the very first typecheck a worker runs is already narrowed and green. Verified `@/encryption` does not import `wasm-inline.ts`, so a program rooted at the `*.test-d.ts` files does not reach the broken modules. + +a) Create `packages/stack/tsconfig.typecheck.json` — narrow roots so tsc only pulls the type-test files and what they actually import: + +```json +{ + "extends": "./tsconfig.json", + "include": ["__tests__/**/*.test-d.ts"] +} +``` + +b) Add a scoped `typecheck` block to `packages/stack/vitest.config.ts`: + +```ts +import { resolve } from 'node:path' +import { defineConfig } from 'vitest/config' + +export default defineConfig({ + resolve: { + alias: { + '@/': resolve(__dirname, './src') + '/', + }, + }, + test: { + typecheck: { + // Scoped tsconfig keeps the 124 pre-existing wasm-inline typecheck errors + // out of scope (tracked as a follow-up). Run via the `test:types` script + // with `--typecheck.only` so the runtime suites do NOT also execute. + tsconfig: './tsconfig.typecheck.json', + include: ['__tests__/**/*.test-d.ts'], + }, + }, +}) +``` + +c) Add a `test:types` script to `packages/stack/package.json`. Use `--typecheck.only` (Vitest **3.2.4**, confirmed in the repo, supports it) so ONLY the type tests run — `--typecheck` alone would ALSO run the runtime suites (including the credential/network-sensitive ones): + +```json + "test:types": "vitest --run --typecheck.only", +``` + +- [ ] **Step 3: Run the scoped type tests to verify they pass** + +Run: `pnpm run test:types` +Expected: PASS — `schema-v3.test-d.ts` type-checks (and the existing `types.test-d.ts` does too); ZERO errors; no runtime suites executed. (If `@/schema/v3` types were missing or `InferPlaintext`/`InferEncrypted` produced the wrong shape, `toEqualTypeOf` would surface a type error here. Tasks 1-2 already define these, so it type-checks green on first run.) + +> **STOP-gate:** if this scoped run still reports the `wasm-inline` errors (e.g. a type-test transitively imports a broken module), narrow `tsconfig.typecheck.json` further (add an `exclude` for `src/wasm-inline.ts` / `__tests__/wasm-inline-normalize.test.ts`) until the run is clean BEFORE wiring CI. Do not wire a red command into CI. + +- [ ] **Step 4: Run the full v3 runtime suite as a guard** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: PASS (all runtime tests still green — no regression from the type-test file). + +- [ ] **Step 5: Wire the scoped type tests into CI** + +In `.github/workflows/tests.yml`, add a step in the `run-tests` job (after `Install dependencies`): + +```yaml + - name: Type tests (stack) + run: pnpm --filter @cipherstash/stack run test:types +``` + +> **Flagged follow-up (NOT fixed here):** the 124 pre-existing package-wide typecheck errors (missing `@cipherstash/{auth,protect-ffi}/wasm-inline` type declarations + `wasm-inline-normalize.test.ts:69`) are a separate cleanup. Enabling typecheck repo-wide / unscoped should be a dedicated follow-up after those are resolved. + +- [ ] **Step 6: Commit** + +```bash +git add packages/stack/__tests__/schema-v3.test-d.ts packages/stack/tsconfig.typecheck.json packages/stack/vitest.config.ts packages/stack/package.json .github/workflows/tests.yml +git commit -m "test(stack): type-level tests for eql_v3 schema DSL + scoped CI typecheck" +``` + +--- + +### Task 5: Widen the public client types to a structural contract (Option A — v3 works with the client) + +**Goal:** make the v3 builders first-class with the client API (`Encryption`, `encrypt`, `decrypt`, `encryptQuery`) by widening the blocking public types to a structural contract that BOTH v2 and v3 builders satisfy. Runtime is untouched (verified structural — no `instanceof` on the encrypt/decrypt/query path). + +**Decision — v3 keeps its OWN `EncryptedTable` class** (not reuse v2's): v3 needs a different column constraint (`EncryptedV3TableColumn`) and a simpler `build()` (no nested-field / ste_vec rewriting). v2 and v3 classes are nominally distinct (private fields) but BOTH structurally satisfy `BuildableColumn` / `BuildableTable`, which is exactly what a single widened type can accept. Reusing v2's class would not help anyway — v3 columns don't satisfy v2's `EncryptedTableColumn` generic constraint. + +**Verified structural members the client actually touches** (so the contract is minimal and correct): +- Column: `getName(): string` (`operations/encrypt.ts:53` etc.), `build(): ColumnSchema` (`helpers/infer-index-type.ts:11,58`). +- Table: `tableName: string` (`operations/encrypt.ts:52` etc.), `build(): { tableName; columns }` (`helpers/model-helpers.ts:268,566`; dynamodb ops; and `buildEncryptConfig(...schemas)` → `tb.build()` at `encryption/index.ts:674`). + +**Files:** +- Modify: `packages/stack/src/types.ts` — define `BuildableColumn` / `BuildableTable`; widen `EncryptionClientConfig.schemas`, `EncryptOptions`, `SearchTerm`, `QueryTermBase`. +- Modify: `packages/stack/src/schema/index.ts` — widen `buildEncryptConfig`'s parameter type ONLY (backward-compatible; the file already does `import type { Encrypted } from '@/types'`, so referencing `BuildableTable` from `@/types` adds no new module cycle). +- Modify: `packages/stack/src/encryption/operations/encrypt.ts` — internal consumer of the widened `EncryptOptions` (Step 3b). +- Modify: `packages/stack/src/encryption/operations/bulk-encrypt.ts` — internal consumer of the widened `EncryptOptions` (Step 3b). +- Modify: `packages/stack/src/encryption/helpers/infer-index-type.ts` — internal consumer of the widened query-term `column` (Step 3b). +- Test: append a `describe` block to `packages/stack/__tests__/schema-v3.test-d.ts`. + +> **Internal-consumer note (verified):** widening the public aliases is NOT enough on its own — three internal files store/accept those values in narrow v2 types and would fail typecheck. They are widened in Step 3b. Verified NOT needing changes (do not over-widen): the `EncryptionClient` class (stores only `client` + `encryptConfig`, passes `opts` straight through); `operations/encrypt-query.ts` / `batch-encrypt-query.ts` (store the public widened types directly, no narrow re-declaration); and the entire MODEL path (`encrypt-model.ts`, `bulk-encrypt-models.ts`, `model-helpers.ts`), which intentionally stays narrow because the generic model methods are NOT widened in this increment. + +**Interfaces (define in `src/types.ts`, alongside the other public client types):** + +```ts +import type { + ColumnSchema, + EncryptedColumn, + // ...existing imports (EncryptedColumn already imported; EncryptedField, EncryptedTable, EncryptedTableColumn) +} from '@/schema' + +/** Structural contract for a column builder the client can consume for STORAGE + * (`encrypt`). Satisfied by v2 `EncryptedColumn` / `EncryptedField` AND v3 + * `EncryptedTextSearchColumn` — fields ARE encryptable, so this stays wide. */ +export interface BuildableColumn { + getName(): string + build(): ColumnSchema +} + +/** Structural contract for a column the client can consume for QUERIES + * (`encryptQuery` / search terms). Narrower than `BuildableColumn`: it must + * EXCLUDE non-queryable `EncryptedField` (a field has no indexes). A v2 + * `EncryptedColumn` qualifies via the nominal arm; a v3 queryable concrete + * type qualifies via the `getEqlType()` structural arm; `EncryptedField` (no + * `getEqlType`, not an `EncryptedColumn`) is rejected. */ +export type BuildableQueryColumn = + | EncryptedColumn + | (BuildableColumn & { getEqlType(): string }) + +/** Structural contract for a table builder the client can consume. Satisfied by + * v2 and v3 `EncryptedTable` alike. */ +export interface BuildableTable { + tableName: string + build(): { tableName: string; columns: Record<string, ColumnSchema> } +} +``` + +- [ ] **Step 1: Write the failing client-integration acceptance tests** + +Append to `packages/stack/__tests__/schema-v3.test-d.ts`. First extend its imports — `import type { Encrypted } from '@/types'` and `encryptedColumn` from `@/schema` are ALREADY present from Task 4, so add ONLY the genuinely new symbols: + +```ts +// NEW imports for Task 5 (Encrypted + encryptedColumn already imported in Task 4): +import { Encryption, EncryptionClient } from '@/encryption' +// extend the existing `import { encryptedColumn } from '@/schema'` to also bring in: +import { + encryptedColumn, + encryptedField, + encryptedTable as v2EncryptedTable, +} from '@/schema' +``` + +Then append: + +```ts +describe('eql_v3 client integration (type-level acceptance)', () => { + const v3users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + + it('Encryption accepts a v3 schema', () => { + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v3users] }) + }) + + it('encrypt accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('encryptQuery accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('decrypt accepts an Encrypted value (round-trip target type; schema-independent)', () => { + const client = {} as EncryptionClient + expectTypeOf(client.decrypt).toBeCallableWith({} as Encrypted) + }) + + it('BACKWARD COMPAT: v2 tables/columns still satisfy the widened types', () => { + const v2users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v2users] }) + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + // a v2 EncryptedColumn is STILL queryable (nominal arm of BuildableQueryColumn) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + }) + + it('a non-queryable v2 EncryptedField is encryptable but NOT queryable', () => { + const v2usersWithField = v2EncryptedTable('users', { + profile: { email: encryptedField('email') }, + }) + const client = {} as EncryptionClient + + // POSITIVE: a field IS encryptable (storage path = BuildableColumn) + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2usersWithField, + column: v2usersWithField.profile.email, + }) + + // NEGATIVE: a field is NOT queryable. The query path uses + // BuildableQueryColumn, which excludes EncryptedField (no indexes). If the + // query path were instead widened to BuildableColumn (the rejected + // Batch-2/3 design), this call would compile and only fail at runtime with + // "no indexes configured" — so this test guards against that re-widening. + // + // The mismatch is a DEEP object-literal property error, so tsc reports it on + // the `column:` line — the `@ts-expect-error` MUST sit directly above that + // line (not above the call), or you get TS2578 "unused directive" + the real + // error leaking. (Mirror of Task 4's v2-column-rejected test placement.) + client.encryptQuery('alice@example.com', { + table: v2usersWithField, + // @ts-expect-error - EncryptedField is not assignable to BuildableQueryColumn + column: v2usersWithField.profile.email, + }) + }) +}) +``` + +- [ ] **Step 2: Run the type tests to verify they fail** + +Run: `pnpm run test:types` (script added in Task 4) +Expected: FAIL — the v3 `Encryption` / `encrypt` / `encryptQuery` assertions error because `EncryptedTextSearchColumn` / v3 `EncryptedTable` are not assignable to the still-nominal pre-Task-5 v2 types. These clear after Step 3. + +(The v2 backward-compat `encrypt`/`encryptQuery` assertions and `decrypt` already pass. The field tests also already pass: pre-Task-5 `QueryTermBase.column` is the original nominal `EncryptedColumn`, so the `@ts-expect-error` on querying a field is already a valid suppression — those tests stay green through Step 3, guarding against any future re-widening of the query path to `BuildableColumn`.) + +- [ ] **Step 3a: Define the structural contract and widen the public types** + +In `packages/stack/src/types.ts`: +1. Add `ColumnSchema` to the existing `@/schema` type import (`EncryptedColumn` is already imported there). +2. Add the `BuildableColumn` / `BuildableQueryColumn` / `BuildableTable` definitions (above). +3. Widen the blocking surfaces. Note the **storage vs query split**: `EncryptOptions` (encrypt) accepts `BuildableColumn` (columns AND fields), while `SearchTerm` / `QueryTermBase` (encryptQuery) accept the narrower `BuildableQueryColumn` so a non-queryable field is rejected at the type layer: + +```ts +export type EncryptionClientConfig = { + schemas: AtLeastOneCsTable<BuildableTable> + config?: ClientConfig +} + +export type EncryptOptions = { + column: BuildableColumn // storage: fields are encryptable, so stays wide + table: BuildableTable +} + +export type SearchTerm = { + value: JsPlaintext + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable + returnType?: EncryptedReturnType +} + +export type QueryTermBase = { + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable + queryType?: QueryTypeName + returnType?: EncryptedReturnType +} +``` + +In `packages/stack/src/schema/index.ts`, widen `buildEncryptConfig`'s parameter (the ONLY permitted edit to the v2 module — pure widening, no behavior change): + +```ts +import type { BuildableTable, Encrypted } from '@/types' + +export function buildEncryptConfig( + ...protectTables: Array<BuildableTable> +): EncryptConfig { + // body unchanged — already only calls tb.build() +} +``` + +> **Do NOT touch** the generic schema-aware model methods `encryptModel<S extends EncryptedTableColumn>` / `bulkEncryptModels` (`encryption/index.ts:394,489`) or `EncryptedFromSchema` / `InferPlaintext` / `EncryptedFields`. They must keep inferring `S` from `EncryptedTable<S>` so v2 field-level inference is preserved. v3 support for the model methods is a future increment (v3 columns don't satisfy `EncryptedTableColumn`). The `EncryptedTable<T> & T` accessor and v2 inference must be re-verified green (Step 4). +> +> **Fallback (if the team forbids ANY v2-module edit):** instead of widening `buildEncryptConfig`, leave it as-is and change `Encryption()` (`encryption/index.ts`) to assemble the config inline from the structural `schemas` (`for (const tb of schemas) { const d = tb.build(); config.tables[d.tableName] = d.columns }`). This keeps `src/schema/index.ts` pristine at the cost of ~6 duplicated lines in the client. + +- [ ] **Step 3b: Widen the internal consumers the public change forces** + +After Step 3a, the package will NOT typecheck until the internal consumers that store/accept the widened values are widened too. All three only call `.getName()`, `.tableName`, and `column.build().indexes` — so `BuildableColumn` / `BuildableTable` are sufficient (no richer contract). Widen exactly these, and nothing in the model path: + +1. **`src/encryption/operations/encrypt.ts`** — `EncryptOperation`: + - field `private column: EncryptedColumn | EncryptedField` (:27) → `private column: BuildableColumn` + - field `private table: EncryptedTable<EncryptedTableColumn>` (:28) → `private table: BuildableTable` + - `getOperation()` return type's `column` / `table` (:112-113) → `BuildableColumn` / `BuildableTable` + - imports: add `BuildableColumn, BuildableTable` to the `@/types` import; drop the now-unused `EncryptedColumn, EncryptedField, EncryptedTable, EncryptedTableColumn` from the `@/schema` import (if nothing else uses them). + - The constructor already takes `opts: EncryptOptions` (widened) — no signature change; only the field/return types. + +2. **`src/encryption/operations/bulk-encrypt.ts`** — `BulkEncryptOperation`: + - module fn `createEncryptPayloads(column: EncryptedColumn | EncryptedField, table: EncryptedTable<EncryptedTableColumn>, ...)` (:28-29) → `column: BuildableColumn, table: BuildableTable` + - fields `private column` (:66) / `private table` (:67) → `BuildableColumn` / `BuildableTable` + - **`BulkEncryptOperation.getOperation()` return type (:141-142)** — REQUIRED widen-site: it re-exposes `column: EncryptedColumn | EncryptedField` (:141) and `table: EncryptedTable<EncryptedTableColumn>` (:142) → `BuildableColumn` / `BuildableTable`. (This return value is destructured and consumed by `BulkEncryptOperationWithLockContext.execute()` at :168, which only uses `.getName()` / `.tableName`.) Do NOT miss this — leaving it narrow keeps `bulk-encrypt.ts` red. (Note: this is `getOperation()`'s return type on `BulkEncryptOperation`, NOT a member of the `*WithLockContext` class.) + - same import swap (`@/types` gains `BuildableColumn, BuildableTable`; drop unused `@/schema` narrow types). + +3. **`src/encryption/helpers/infer-index-type.ts`** — index inference (QUERY path only — verified reached solely via `resolveIndexType` from `encrypt-query.ts:72,165` and `batch-encrypt-query.ts:51`, NOT from the storage path): + - `inferIndexType(column: EncryptedColumn)` (:10), `validateIndexType(column: EncryptedColumn, ...)` (:55), `resolveIndexType(column: EncryptedColumn, ...)` (:87) → `column: BuildableQueryColumn` in all three (NOT `BuildableColumn` — these run only for queries, so they should reject non-queryable fields too). + - import: replace `import type { EncryptedColumn } from '@/schema'` with `import type { BuildableQueryColumn } from '@/types'`. + - Bodies are unchanged: they read `column.build().indexes` and `column.getName()`, both available on `BuildableQueryColumn` (its `EncryptedColumn` arm and its `BuildableColumn & …` arm each provide `getName()` + `build()`). + +> **Do NOT widen the model path.** `encrypt-model.ts`, `bulk-encrypt-models.ts`, and `model-helpers.ts` keep `EncryptedTable<EncryptedTableColumn>` / `EncryptedTable<S>` — they are fed by the generic `encryptModel<S extends EncryptedTableColumn>` methods which are intentionally left narrow (preserves v2 inference; v3 model support is a later increment). Widening them would over-reach and could disturb inference. +> +> **WASM-inline boundary (documented, not fixed here).** `src/wasm-inline.ts:314-320` has `getColumnName(col)` doing `if (col instanceof EncryptedColumn || col instanceof EncryptedField) … else throw`. After widening `EncryptOptions['column']` to `BuildableColumn` this still type-checks (an `instanceof` guard narrows a wider type fine) and `wasm-inline.ts` is outside the scoped typecheck graph (`@/encryption` does not import it; the `test:types` tsconfig roots only the `*.test-d.ts` files), so it does NOT turn the package red — but a v3 column routed through the WASM-inline entry would hit the `else throw` at RUNTIME. The batch-2 "no `instanceof`" finding was explicitly scoped to `operations/*.ts`; the WASM-inline entry does not yet accept v3 columns, which is a deferred, documented boundary (not a latent surprise). + +- [ ] **Step 4: Run the full suite to verify pass + no regression** + +```bash +pnpm run test:types # v3 acceptance + v2 backward-compat + existing types.test-d.ts all green +pnpm exec vitest run # all runtime tests still pass (encryptModel inference unaffected) +``` + +Expected: all green. In particular `__tests__/types.test-d.ts` (v2 inference, `EncryptedFromSchema`, `encryptModel` schema-aware return types) must still pass — proving the widening did not narrow or break v2. + +- [ ] **Step 5: Commit** + +```bash +git add packages/stack/src/types.ts packages/stack/src/schema/index.ts \ + packages/stack/src/encryption/operations/encrypt.ts \ + packages/stack/src/encryption/operations/bulk-encrypt.ts \ + packages/stack/src/encryption/helpers/infer-index-type.ts \ + packages/stack/__tests__/schema-v3.test-d.ts +git commit -m "feat(stack): widen public client types so v3 builders work with the client" +``` + +--- + +### Task 6: Changeset + +**Files:** +- Create: `.changeset/eql-v3-text-search.md` + +**Interfaces:** none (release metadata only). The repo uses Changesets (`.changeset/config.json`); frontmatter keys are package `name`s. `packages/stack/package.json` name is `@cipherstash/stack`. + +- [ ] **Step 1: Create the changeset** + +Create `.changeset/eql-v3-text-search.md` (minor — additive `./schema/v3` subpath + exports, plus backward-compatible public-type widening; no breaking changes): + +```md +--- +"@cipherstash/stack": minor +--- + +Add the EQL v3 `text_search` authoring DSL on a new `@cipherstash/stack/schema/v3` +subpath (`encryptedTextSearchColumn`, v3 `encryptedTable` / `buildEncryptConfig`). +The v3 builders emit the existing `EncryptConfig` shape, so encryption, payloads, +and query paths are unchanged at runtime. + +Also widens the public client types (`EncryptionClientConfig.schemas`, +`EncryptOptions`, `SearchTerm`/`EncryptQueryOptions`) to a structural contract so +both v2 and v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / +`encryptQuery`. This is a backward-compatible widening — existing v2 usage is +unaffected. +``` + +- [ ] **Step 2: Verify the changeset is valid** + +Run: `pnpm exec changeset status` (from the repo root) +Expected: lists a pending `minor` bump for `@cipherstash/stack`, no errors. (If `changeset status` is unavailable in this environment, confirm the frontmatter key exactly matches the package `name` and the bump keyword is one of `major`/`minor`/`patch`.) + +- [ ] **Step 3: Commit** + +```bash +git add .changeset/eql-v3-text-search.md +git commit -m "chore(stack): changeset for eql_v3 text_search DSL (minor)" +``` + +--- + +## Self-Review + +**Spec coverage:** +- Public API (`encryptedTextSearchColumn`, v3 `encryptedTable`, v3 `buildEncryptConfig`) → Tasks 1-2. +- `.freeTextSearch(opts?)` as tuning-only with per-key replace merge → Task 1, Steps 1 & 3 (override + tuning-only tests). +- Pinned `build()` output (`cast_as: 'string'` + three indexes, defaults) → Task 1, default-config test. +- Load-bearing v2/v3 equivalence assertion → Task 1, "LOAD-BEARING" test (imports v2 `encryptedColumn`). +- `'eql_v3.text_search'` via `getEqlType()` method (no property getter), absent from `build()` → Task 1, getEqlType + absence tests. +- `buildEncryptConfig` → valid `EncryptConfig` (`v: 1`) passing `encryptConfigSchema.parse` → Task 2. +- `InferPlaintext` / `InferEncrypted` → Task 4 (type) + Task 2 (definition). +- New `@cipherstash/stack/schema/v3` subpath (exports + tsup) → Task 3. +- No shared mutable state (per-instance defaults + cloned `build()`) → Task 1 (`defaultMatchOpts()` factory + independent-mutation test). +- **Client integration (Option A):** widen public types AND the internal consumers they force so v3 builders work with `Encryption` / `encrypt` / `decrypt` / `encryptQuery`; storage path (`encrypt`, `operations/encrypt.ts`, `operations/bulk-encrypt.ts`) uses `BuildableColumn` (accepts fields), query path (`encryptQuery`, `helpers/infer-index-type.ts`) uses the narrower `BuildableQueryColumn` (rejects non-queryable fields); model path left narrow; v2 backward-compat preserved → Task 5 (Steps 3a + 3b). +- Type tests enforced in CI (scoped typecheck, `--typecheck.only`) → Task 4, Steps 2-3 (scoped config + script) and Step 5 (CI wiring). +- Changeset (minor) for the public-surface change → Task 6. +- v2 module: runtime + existing exported shapes untouched; ONLY a backward-compatible `buildEncryptConfig` param widening (Task 5) — see Global Constraints. +- Non-goals (v3 in the generic model methods, DDL, transition tooling, query dialect, other concrete types, nested fields) → not implemented (correctly out of scope). + +**Placeholder scan:** No TBD/TODO/"handle edge cases" present; every code step contains complete, runnable code. + +**Type consistency:** `EncryptedTextSearchColumn`, `encryptedTextSearchColumn`, `EncryptedTable`, `encryptedTable`, `buildEncryptConfig`, `EncryptedV3TableColumn`, `InferPlaintext`, `InferEncrypted`, `TEXT_SEARCH_EQL_TYPE`, the `defaultMatchOpts()` factory, `getEqlType()` (method only — no property getter; also the query-path discriminator in `BuildableQueryColumn`), and the structural `BuildableColumn` / `BuildableQueryColumn` / `BuildableTable` contract (Task 5) are used identically across tasks and tests. `build()` returns `ColumnSchema`; `EncryptedTable.build()` returns `{ tableName, columns: Record<string, ColumnSchema> }`, matching both `buildEncryptConfig`'s consumption and the `BuildableTable` contract. + +--- + +## Execution Handoff + +Plan complete and saved to `docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md`. Two execution options: + +1. **Subagent-Driven (recommended)** — dispatch a fresh subagent per task, review between tasks, fast iteration. +2. **Inline Execution** — execute tasks in this session using executing-plans, batch execution with checkpoints. + +Which approach? +</content> +</invoke> diff --git a/docs/superpowers/plans/2026-07-01-eql-v3-typed-schema.md b/docs/superpowers/plans/2026-07-01-eql-v3-typed-schema.md new file mode 100644 index 00000000..8f5e10b6 --- /dev/null +++ b/docs/superpowers/plans/2026-07-01-eql-v3-typed-schema.md @@ -0,0 +1,1536 @@ +# EQL v3 Typed Schema Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Expand `@cipherstash/stack/schema/v3` from the current `text_search` slice to all generated EQL v3 SQL domains with domain-precise builders, explicit query capability metadata, and structurally widened client/model support while preserving v2 behavior. + +**Architecture:** Keep v3 isolated under `packages/stack/src/schema/v3/index.ts` and the `@cipherstash/stack/schema/v3` export. Implement one v3 column class/builder per EQL v3 domain using a shared internal column base parameterized by the full literal domain definition (`eqlType`, `castAs`, capabilities), not by capabilities alone. Client query typing should accept v3 columns only when they expose capability metadata and `isQueryable(): true`; storage-only v3 columns remain encryptable but not queryable. + +**Tech Stack:** TypeScript, Vitest runtime tests, Vitest type tests, tsup package build, `@cipherstash/protect-ffi`, existing `ColumnSchema`/`EncryptConfig` v1 config shape. + +--- + +## File Structure Map + +**Modify:** +- `packages/stack/src/schema/v3/index.ts` + - Owns all v3 builders, domain metadata, table builder, `buildEncryptConfig`, and v3 `InferPlaintext` / `InferEncrypted`. +- `packages/stack/src/types.ts` + - Tightens `BuildableQueryColumn`; widens model schema typing from v2-only columns to structural buildable table columns while preserving literal schema keys through each table's `_columnType` brand. +- `packages/stack/src/encryption/index.ts` + - Updates `encryptModel` and `bulkEncryptModels` generics and table parameter types to accept v3 tables. +- `packages/stack/src/encryption/helpers/model-helpers.ts` + - Replaces v2 `EncryptedTable<EncryptedTableColumn>` annotations with structural `BuildableTable`. +- `packages/stack/src/encryption/operations/encrypt-model.ts` + - Replaces v2 table annotations with `BuildableTable`. +- `packages/stack/src/encryption/operations/bulk-encrypt-models.ts` + - Replaces v2 table annotations with `BuildableTable`. +- `packages/stack/src/wasm-inline.ts` + - Widens WASM schema config type to structural buildable tables if needed; keeps structural `getColumnName`. +- `packages/stack/vitest.config.ts` + - Fixes or isolates `@cipherstash/protect-ffi/wasm-inline` import resolution for `wasm-inline-column-name.test.ts`. +- `packages/stack/package.json` + - Keep existing `./schema/v3` export and `db:eql-v3:install`; add no new subpath unless tests prove required. + +**Modify tests:** +- `packages/stack/__tests__/schema-v3.test.ts` + - Runtime builder/config/capability tests for all v3 domains. +- `packages/stack/__tests__/schema-v3.test-d.ts` + - Type-level tests for all builders, queryability, inferred plaintext/encrypted model shapes, and v2 compatibility. +- `packages/stack/__tests__/schema-v3-client.test.ts` + - Live env-gated client tests expanded to representative storage-only/equality/order/match/search columns. +- `packages/stack/__tests__/schema-v3-pg.test.ts` + - Keep guarded Postgres `text_search` coverage; add representative non-text EQL v3 domains when the SQL fixture supports them. +- `packages/stack/__tests__/wasm-inline-column-name.test.ts` + - Keep focused column-name test; update import style only if needed after Vitest resolution fix. + +**Create:** +- `.changeset/eql-v3-typed-schema.md` + - Public API addition for `@cipherstash/stack`. + +**Do not modify:** +- `packages/stack/src/schema/index.ts` + - v2 schema API remains stable. +- Payload contracts and Result shapes. +- Any code that logs plaintext. + +--- + +### Task 1: Baseline And Source-Of-Truth Snapshot + +**Files:** +- Read only: `packages/stack/src/schema/v3/index.ts` +- Read only: `<eql-v3-worktree>/crates/eql-bindings/src/v3/inventory.rs` +- Read only: `<eql-v3-worktree>/crates/eql-bindings/schema/v3/*.json` + +- [ ] **Step 1: Confirm branch and dirty state** + +Run: + +```bash +git status --short --branch +``` + +Expected: + +```text +## feat/eql-v3-text-search-schema...origin/feat/eql-v3-text-search-schema +``` + +Also expect currently untracked v3 live-test/helper files and the `packages/stack/package.json` script change. Do not revert them. + +- [ ] **Step 2: Confirm complete v3 domain inventory** + +Run: + +```bash +sed -n '1,140p' <eql-v3-worktree>/crates/eql-bindings/src/v3/inventory.rs +``` + +Expected: inventory includes exactly these domain identifiers: + +```text +int4 int4_eq int4_ord_ore int4_ord +int2 int2_eq int2_ord_ore int2_ord +int8 int8_eq int8_ord_ore int8_ord +date date_eq date_ord_ore date_ord +timestamptz timestamptz_eq timestamptz_ord_ore timestamptz_ord +numeric numeric_eq numeric_ord_ore numeric_ord +text text_eq text_match text_ord_ore text_ord text_search +bool +float4 float4_eq float4_ord_ore float4_ord +float8 float8_eq float8_ord_ore float8_ord +``` + +- [ ] **Step 3: Confirm capability rule from JSON schemas** + +Run: + +```bash +rg '"required"' <eql-v3-worktree>/crates/eql-bindings/schema/v3 -n +``` + +Expected: +- Schemas with required `hm` support equality. +- Schemas with required `ob` support order/range. +- Schemas with required `bf` support free-text search. +- Those exposing only `v`, `i`, `c` are storage-only. + +--- + +### Task 2: Write Failing Runtime Tests For All v3 Builders + +**Files:** +- Modify: `packages/stack/__tests__/schema-v3.test.ts` + +- [ ] **Step 1: Add import coverage for every new builder and class** + +Replace the v3 import block with this full import list: + +```ts +import { + buildEncryptConfig, + EncryptedBoolColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedFloat4Column, + EncryptedFloat4EqColumn, + EncryptedFloat4OrdColumn, + EncryptedFloat4OrdOreColumn, + EncryptedFloat8Column, + EncryptedFloat8EqColumn, + EncryptedFloat8OrdColumn, + EncryptedFloat8OrdOreColumn, + EncryptedInt2Column, + EncryptedInt2EqColumn, + EncryptedInt2OrdColumn, + EncryptedInt2OrdOreColumn, + EncryptedInt4Column, + EncryptedInt4EqColumn, + EncryptedInt4OrdColumn, + EncryptedInt4OrdOreColumn, + EncryptedInt8Column, + EncryptedInt8EqColumn, + EncryptedInt8OrdColumn, + EncryptedInt8OrdOreColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedTable, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestamptzColumn, + EncryptedTimestamptzEqColumn, + EncryptedTimestamptzOrdColumn, + EncryptedTimestamptzOrdOreColumn, + encryptedBoolColumn, + encryptedDateColumn, + encryptedDateEqColumn, + encryptedDateOrdColumn, + encryptedDateOrdOreColumn, + encryptedFloat4Column, + encryptedFloat4EqColumn, + encryptedFloat4OrdColumn, + encryptedFloat4OrdOreColumn, + encryptedFloat8Column, + encryptedFloat8EqColumn, + encryptedFloat8OrdColumn, + encryptedFloat8OrdOreColumn, + encryptedInt2Column, + encryptedInt2EqColumn, + encryptedInt2OrdColumn, + encryptedInt2OrdOreColumn, + encryptedInt4Column, + encryptedInt4EqColumn, + encryptedInt4OrdColumn, + encryptedInt4OrdOreColumn, + encryptedInt8Column, + encryptedInt8EqColumn, + encryptedInt8OrdColumn, + encryptedInt8OrdOreColumn, + encryptedNumericColumn, + encryptedNumericEqColumn, + encryptedNumericOrdColumn, + encryptedNumericOrdOreColumn, + encryptedTable, + encryptedTextColumn, + encryptedTextEqColumn, + encryptedTextMatchColumn, + encryptedTextOrdColumn, + encryptedTextOrdOreColumn, + encryptedTextSearchColumn, + encryptedTimestamptzColumn, + encryptedTimestamptzEqColumn, + encryptedTimestamptzOrdColumn, + encryptedTimestamptzOrdOreColumn, +} from '@/schema/v3' +``` + +- [ ] **Step 2: Add a complete table-driven domain test** + +Add this test near the top of `schema-v3.test.ts`: + +```ts +const domainCases = [ + ['eql_v3.int4', encryptedInt4Column, EncryptedInt4Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int4_eq', encryptedInt4EqColumn, EncryptedInt4EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int4_ord_ore', encryptedInt4OrdOreColumn, EncryptedInt4OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int4_ord', encryptedInt4OrdColumn, EncryptedInt4OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int2', encryptedInt2Column, EncryptedInt2Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int2_eq', encryptedInt2EqColumn, EncryptedInt2EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int2_ord_ore', encryptedInt2OrdOreColumn, EncryptedInt2OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int2_ord', encryptedInt2OrdColumn, EncryptedInt2OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int8', encryptedInt8Column, EncryptedInt8Column, 'bigint', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int8_eq', encryptedInt8EqColumn, EncryptedInt8EqColumn, 'bigint', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int8_ord_ore', encryptedInt8OrdOreColumn, EncryptedInt8OrdOreColumn, 'bigint', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int8_ord', encryptedInt8OrdColumn, EncryptedInt8OrdColumn, 'bigint', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.date', encryptedDateColumn, EncryptedDateColumn, 'date', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.date_eq', encryptedDateEqColumn, EncryptedDateEqColumn, 'date', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.date_ord_ore', encryptedDateOrdOreColumn, EncryptedDateOrdOreColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.date_ord', encryptedDateOrdColumn, EncryptedDateOrdColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.timestamptz', encryptedTimestamptzColumn, EncryptedTimestamptzColumn, 'date', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.timestamptz_eq', encryptedTimestamptzEqColumn, EncryptedTimestamptzEqColumn, 'date', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.timestamptz_ord_ore', encryptedTimestamptzOrdOreColumn, EncryptedTimestamptzOrdOreColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.timestamptz_ord', encryptedTimestamptzOrdColumn, EncryptedTimestamptzOrdColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.numeric', encryptedNumericColumn, EncryptedNumericColumn, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.numeric_eq', encryptedNumericEqColumn, EncryptedNumericEqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.numeric_ord_ore', encryptedNumericOrdOreColumn, EncryptedNumericOrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.numeric_ord', encryptedNumericOrdColumn, EncryptedNumericOrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.text', encryptedTextColumn, EncryptedTextColumn, 'string', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.text_eq', encryptedTextEqColumn, EncryptedTextEqColumn, 'string', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.text_match', encryptedTextMatchColumn, EncryptedTextMatchColumn, 'string', { match: { tokenizer: { kind: 'ngram', token_length: 3 }, token_filters: [{ kind: 'downcase' }], k: 6, m: 2048, include_original: true } }, { equality: false, orderAndRange: false, freeTextSearch: true }], + ['eql_v3.text_ord_ore', encryptedTextOrdOreColumn, EncryptedTextOrdOreColumn, 'string', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.text_ord', encryptedTextOrdColumn, EncryptedTextOrdColumn, 'string', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.bool', encryptedBoolColumn, EncryptedBoolColumn, 'boolean', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float4', encryptedFloat4Column, EncryptedFloat4Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float4_eq', encryptedFloat4EqColumn, EncryptedFloat4EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float4_ord_ore', encryptedFloat4OrdOreColumn, EncryptedFloat4OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.float4_ord', encryptedFloat4OrdColumn, EncryptedFloat4OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.float8', encryptedFloat8Column, EncryptedFloat8Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float8_eq', encryptedFloat8EqColumn, EncryptedFloat8EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float8_ord_ore', encryptedFloat8OrdOreColumn, EncryptedFloat8OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.float8_ord', encryptedFloat8OrdColumn, EncryptedFloat8OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], +] as const + +describe('eql_v3 concrete domain columns', () => { + it.each(domainCases)('%s builder exposes name, config, type, and capabilities', (eqlType, factory, Klass, castAs, indexes, capabilities) => { + const col = factory('value') + expect(col).toBeInstanceOf(Klass) + expect(col.getName()).toBe('value') + expect(col.getEqlType()).toBe(eqlType) + expect(col.getQueryCapabilities()).toStrictEqual(capabilities) + expect(col.isQueryable()).toBe(Object.values(capabilities).some(Boolean)) + expect(col.build()).toStrictEqual({ cast_as: castAs, indexes }) + expect(col.build()).not.toHaveProperty('eqlType') + expect(col.build()).not.toHaveProperty('queryCapabilities') + }) +}) +``` + +- [ ] **Step 3: Keep and adapt existing `text_search` tests** + +Keep existing `text_search` tests, but add: + +```ts +expect(encryptedTextSearchColumn('email').getQueryCapabilities()).toStrictEqual({ + equality: true, + orderAndRange: true, + freeTextSearch: true, +}) +expect(encryptedTextSearchColumn('email').isQueryable()).toBe(true) +``` + +- [ ] **Step 4: Run runtime test and confirm failure** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3.test.ts +``` + +Expected: FAIL with missing exports such as `encryptedInt4Column` and missing methods `getQueryCapabilities` / `isQueryable`. + +--- + +### Task 3: Implement v3 Domain Column Base And Builders + +**Files:** +- Modify: `packages/stack/src/schema/v3/index.ts` + +- [ ] **Step 1: Add shared capability and full domain-definition types** + +Add near the top of `schema/v3/index.ts`: + +```ts +export type QueryCapabilities = Readonly<{ + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean +}> + +type PlaintextKind = 'string' | 'number' | 'bigint' | 'boolean' | 'date' + +type V3DomainDefinition = Readonly<{ + eqlType: `eql_v3.${string}` + castAs: PlaintextKind + capabilities: QueryCapabilities +}> + +type QueryableFlag<D extends V3DomainDefinition> = + D['capabilities'] extends { equality: false; orderAndRange: false; freeTextSearch: false } + ? false + : true + +const STORAGE_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: false, +} as const + +const EQUALITY_ONLY = { + equality: true, + orderAndRange: false, + freeTextSearch: false, +} as const + +const ORDER_AND_RANGE = { + equality: true, + orderAndRange: true, + freeTextSearch: false, +} as const + +const MATCH_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: true, +} as const + +const TEXT_SEARCH = { + equality: true, + orderAndRange: true, + freeTextSearch: true, +} as const + +const INT4 = { eqlType: 'eql_v3.int4', castAs: 'number', capabilities: STORAGE_ONLY } as const +const INT4_EQ = { eqlType: 'eql_v3.int4_eq', castAs: 'number', capabilities: EQUALITY_ONLY } as const +const INT4_ORD_ORE = { eqlType: 'eql_v3.int4_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE } as const +const INT4_ORD = { eqlType: 'eql_v3.int4_ord', castAs: 'number', capabilities: ORDER_AND_RANGE } as const +``` + +Every concrete domain must get its own `as const` domain definition object. This is load-bearing: empty subclasses are not nominal in TypeScript, so the base class must carry literal `eqlType`/`castAs` data in its private definition field. Do not type columns as `EncryptedV3Column<typeof STORAGE_ONLY>`; that makes all storage-only domains mutually assignable and breaks plaintext inference. + +- [ ] **Step 2: Add config helpers** + +Add these helpers before column classes: + +```ts +function indexesForCapabilities(capabilities: QueryCapabilities): ColumnSchema['indexes'] { + const indexes: ColumnSchema['indexes'] = {} + + if (capabilities.equality && !capabilities.orderAndRange) { + indexes.unique = { token_filters: [] } + } + + if (capabilities.orderAndRange) { + indexes.ore = {} + } + + if (capabilities.freeTextSearch) { + const match = defaultMatchOpts() + indexes.match = { + ...match, + tokenizer: { ...match.tokenizer }, + token_filters: match.token_filters.map((f) => ({ ...f })), + } + } + + return indexes +} + +function isQueryableCapabilities(capabilities: QueryCapabilities): boolean { + return capabilities.equality || capabilities.orderAndRange || capabilities.freeTextSearch +} +``` + +Important: `orderAndRange` domains use `{ ore: {} }` only. Do not also emit `unique`; the EQL v3 `ob` key supports equality and range. + +- [ ] **Step 3: Add generic base class** + +Add: + +```ts +class EncryptedV3Column<D extends V3DomainDefinition> { + constructor( + private readonly columnName: string, + private readonly definition: D, + ) {} + + getName(): string { + return this.columnName + } + + getEqlType(): D['eqlType'] { + return this.definition.eqlType + } + + getQueryCapabilities(): D['capabilities'] { + return this.definition.capabilities + } + + isQueryable(): QueryableFlag<D> { + return isQueryableCapabilities(this.definition.capabilities) as QueryableFlag<D> + } + + build(): ColumnSchema { + return { + cast_as: this.definition.castAs, + indexes: indexesForCapabilities(this.definition.capabilities), + } + } +} +``` + +Because `definition` is a private base field whose type includes literal `eqlType` and `castAs`, `EncryptedBoolColumn` is no longer assignable to `EncryptedInt8Column` even if both are storage-only. + +- [ ] **Step 4: Keep text-search override semantics** + +Change `EncryptedTextSearchColumn` to extend the base but keep its existing `matchOpts`, `freeTextSearch(opts?)`, and deep-clone behavior. + +Expected final shape: + +```ts +const TEXT_SEARCH_DOMAIN = { + eqlType: TEXT_SEARCH_EQL_TYPE, + castAs: 'string', + capabilities: TEXT_SEARCH, +} as const + +export class EncryptedTextSearchColumn extends EncryptedV3Column<typeof TEXT_SEARCH_DOMAIN> { + private matchOpts: BuiltMatchIndexOpts + + constructor(columnName: string) { + super(columnName, TEXT_SEARCH_DOMAIN) + this.matchOpts = defaultMatchOpts() + } + + freeTextSearch(opts?: MatchIndexOpts): this { + const defaults = defaultMatchOpts() + this.matchOpts = { + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + } + return this + } + + override build(): ColumnSchema { + return { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + ...this.matchOpts, + tokenizer: { ...this.matchOpts.tokenizer }, + token_filters: this.matchOpts.token_filters.map((f) => ({ ...f })), + }, + }, + } + } +} +``` + +- [ ] **Step 5: Add all concrete classes and builder functions** + +Add these class/function pairs exactly, using the domain constants from Step 1: + +```ts +export class EncryptedInt4Column extends EncryptedV3Column<typeof INT4> {} +export const encryptedInt4Column = (columnName: string) => new EncryptedInt4Column(columnName, INT4) + +export class EncryptedInt4EqColumn extends EncryptedV3Column<typeof INT4_EQ> {} +export const encryptedInt4EqColumn = (columnName: string) => new EncryptedInt4EqColumn(columnName, INT4_EQ) + +export class EncryptedInt4OrdOreColumn extends EncryptedV3Column<typeof INT4_ORD_ORE> {} +export const encryptedInt4OrdOreColumn = (columnName: string) => new EncryptedInt4OrdOreColumn(columnName, INT4_ORD_ORE) + +export class EncryptedInt4OrdColumn extends EncryptedV3Column<typeof INT4_ORD> {} +export const encryptedInt4OrdColumn = (columnName: string) => new EncryptedInt4OrdColumn(columnName, INT4_ORD) +``` + +Repeat this exact pattern for: + +```text +Int2: int2, int2_eq, int2_ord_ore, int2_ord -> castAs number +Int8: int8, int8_eq, int8_ord_ore, int8_ord -> castAs bigint +Date: date, date_eq, date_ord_ore, date_ord -> castAs date +Timestamptz: timestamptz, timestamptz_eq, timestamptz_ord_ore, timestamptz_ord -> castAs date +Numeric: numeric, numeric_eq, numeric_ord_ore, numeric_ord -> castAs number +Text: text, text_eq, text_match, text_ord_ore, text_ord -> castAs string +Bool: bool -> castAs boolean +Float4: float4, float4_eq, float4_ord_ore, float4_ord -> castAs number +Float8: float8, float8_eq, float8_ord_ore, float8_ord -> castAs number +``` + +For `text_match`, use `MATCH_ONLY`. + +After adding all classes, add a compile-time guard test in `schema-v3.test-d.ts`: + +```ts +it('v3 domain classes remain nominal by literal domain definition', () => { + const int8 = encryptedInt8Column('id64') + const bool = encryptedBoolColumn('active') + + expectTypeOf(int8).not.toEqualTypeOf<typeof bool>() + + // @ts-expect-error - storage-only bool is not assignable to storage-only int8 + const invalid: typeof int8 = bool + void invalid +}) +``` + +- [ ] **Step 6: Run runtime schema tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3.test.ts +``` + +Expected: PASS for schema-v3 runtime tests. If class constructor visibility fails, make the base class constructor `public`. + +--- + +### Task 4: Generalize v3 Table Column Types And Inference + +**Files:** +- Modify: `packages/stack/src/schema/v3/index.ts` +- Modify: `packages/stack/__tests__/schema-v3.test-d.ts` + +- [ ] **Step 1: Replace single-column v3 table type** + +In `schema/v3/index.ts`, replace: + +```ts +export type EncryptedV3TableColumn = { + [key: string]: EncryptedTextSearchColumn +} +``` + +with: + +```ts +export type AnyEncryptedV3Column = + | EncryptedInt4Column + | EncryptedInt4EqColumn + | EncryptedInt4OrdOreColumn + | EncryptedInt4OrdColumn + | EncryptedInt2Column + | EncryptedInt2EqColumn + | EncryptedInt2OrdOreColumn + | EncryptedInt2OrdColumn + | EncryptedInt8Column + | EncryptedInt8EqColumn + | EncryptedInt8OrdOreColumn + | EncryptedInt8OrdColumn + | EncryptedDateColumn + | EncryptedDateEqColumn + | EncryptedDateOrdOreColumn + | EncryptedDateOrdColumn + | EncryptedTimestamptzColumn + | EncryptedTimestamptzEqColumn + | EncryptedTimestamptzOrdOreColumn + | EncryptedTimestamptzOrdColumn + | EncryptedNumericColumn + | EncryptedNumericEqColumn + | EncryptedNumericOrdOreColumn + | EncryptedNumericOrdColumn + | EncryptedTextColumn + | EncryptedTextEqColumn + | EncryptedTextMatchColumn + | EncryptedTextOrdOreColumn + | EncryptedTextOrdColumn + | EncryptedTextSearchColumn + | EncryptedBoolColumn + | EncryptedFloat4Column + | EncryptedFloat4EqColumn + | EncryptedFloat4OrdOreColumn + | EncryptedFloat4OrdColumn + | EncryptedFloat8Column + | EncryptedFloat8EqColumn + | EncryptedFloat8OrdOreColumn + | EncryptedFloat8OrdColumn + +export type EncryptedV3TableColumn = { + [key: string]: AnyEncryptedV3Column +} +``` + +- [ ] **Step 2: Add plaintext inference by literal domain definition** + +Add: + +```ts +type PlaintextFromKind<K extends PlaintextKind> = + K extends 'string' + ? string + : K extends 'number' + ? number + : K extends 'bigint' + ? bigint + : K extends 'boolean' + ? boolean + : K extends 'date' + ? Date + : never + +type PlaintextForColumn<C> = + C extends EncryptedV3Column<infer D> + ? PlaintextFromKind<D['castAs']> + : never +``` + +Do not infer plaintext from a long subclass conditional. Empty subclasses that share the same base generic are structurally assignable; the private base field carrying the full literal domain definition is the stable type discriminator. + +Then replace `InferPlaintext` with: + +```ts +export type InferPlaintext<T extends EncryptedTable<EncryptedV3TableColumn>> = + T extends EncryptedTable<infer C> + ? { [K in keyof C]: PlaintextForColumn<C[K]> } + : never +``` + +Keep `InferEncrypted` as `{ [K in keyof C]: Encrypted }`. + +- [ ] **Step 3: Add type tests for mixed v3 table inference** + +In `schema-v3.test-d.ts`, add: + +```ts +it('InferPlaintext maps v3 concrete domains to plaintext TypeScript types', () => { + const metrics = encryptedTable('metrics', { + name: encryptedTextColumn('name'), + age: encryptedInt4Column('age'), + id64: encryptedInt8Column('id64'), + active: encryptedBoolColumn('active'), + createdAt: encryptedTimestamptzColumn('created_at'), + score: encryptedFloat8Column('score'), + }) + + type Plaintext = InferPlaintext<typeof metrics> + + expectTypeOf<Plaintext>().toEqualTypeOf<{ + name: string + age: number + id64: bigint + active: boolean + createdAt: Date + score: number + }>() +}) +``` + +- [ ] **Step 4: Run type tests and confirm expected failure before query type fixes** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected at this point: may FAIL because `BuildableQueryColumn` still accepts storage-only v3 columns. Continue to Task 5 before requiring a full pass. + +--- + +### Task 5: Require v3 Query Capability Metadata For `encryptQuery` + +**Files:** +- Modify: `packages/stack/src/types.ts` +- Modify: `packages/stack/__tests__/schema-v3.test-d.ts` + +- [ ] **Step 1: Tighten `BuildableQueryColumn`** + +In `types.ts`, replace: + +```ts +export type BuildableQueryColumn = + | EncryptedColumn + | (BuildableColumn & { getEqlType(): string }) +``` + +with: + +```ts +export interface BuildableV3QueryableColumn extends BuildableColumn { + getEqlType(): string + getQueryCapabilities(): { + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean + } + isQueryable(): true +} + +export type BuildableQueryColumn = EncryptedColumn | BuildableV3QueryableColumn +``` + +- [ ] **Step 2: Add positive and negative queryability type tests** + +In `schema-v3.test-d.ts`, add: + +```ts +it('encryptQuery accepts queryable v3 columns with explicit capability metadata', () => { + const users = encryptedTable('users', { + emailEq: encryptedTextEqColumn('email_eq'), + emailMatch: encryptedTextMatchColumn('email_match'), + emailSearch: encryptedTextSearchColumn('email_search'), + createdAt: encryptedTimestamptzOrdColumn('created_at'), + }) + const client = {} as EncryptionClient + + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailEq, + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('ali', { + table: users, + column: users.emailMatch, + queryType: 'freeTextSearch', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + queryType: 'orderAndRange', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailSearch, + queryType: 'equality', + }) +}) + +it('encryptQuery rejects storage-only v3 columns at compile time', () => { + const users = encryptedTable('users', { + email: encryptedTextColumn('email'), + active: encryptedBoolColumn('active'), + }) + const client = {} as EncryptionClient + + client.encryptQuery('alice@example.com', { + table: users, + // @ts-expect-error - storage-only v3 text column is not queryable + column: users.email, + }) + + client.encryptQuery(true, { + table: users, + // @ts-expect-error - storage-only v3 bool column is not queryable + column: users.active, + }) +}) +``` + +- [ ] **Step 3: Preserve literal `isQueryable()` inference in the base class** + +In `schema/v3/index.ts`, storage-only class instances must have `isQueryable(): false` inferred through `QueryableFlag<D>`, and queryable class instances must have `isQueryable(): true`. Do not add per-class overrides unless TypeScript proves the base method fails; 40 overrides add noise and are not needed when domain constants remain `as const`. + +- [ ] **Step 4: Add runtime capability-misuse tests** + +In `schema-v3.test.ts`, import `resolveIndexType` from `@/encryption/helpers/infer-index-type` and add tests that call the query helper path with unsupported query types: + +```ts +it('throws when querying a storage-only v3 column at runtime', () => { + const raw = encryptedTextColumn('raw') + expect(() => resolveIndexType(raw as never)).toThrow(/no indexes configured/) +}) + +it('throws when a query type is not configured on a queryable v3 column', () => { + const matchOnly = encryptedTextMatchColumn('body') + expect(() => resolveIndexType(matchOnly, 'equality')).toThrow( + /Index type "unique" is not configured/, + ) + expect(() => resolveIndexType(matchOnly, 'orderAndRange')).toThrow( + /Index type "ore" is not configured/, + ) +}) +``` + +- [ ] **Step 5: Run type tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected: PASS for `schema-v3.test-d.ts` and existing v2 compatibility type tests. + +Do not make these tests green by weakening `toEqualTypeOf` assertions to `toMatchTypeOf`. The failure mode being guarded here is over-broad inference, so exact type equality is required. + +--- + +### Task 6: Structurally Widen Model Encryption For v3 Tables + +**Files:** +- Modify: `packages/stack/src/types.ts` +- Modify: `packages/stack/src/encryption/index.ts` +- Modify: `packages/stack/src/encryption/helpers/model-helpers.ts` +- Modify: `packages/stack/src/encryption/operations/encrypt-model.ts` +- Modify: `packages/stack/src/encryption/operations/bulk-encrypt-models.ts` +- Modify: `packages/stack/__tests__/schema-v3.test-d.ts` + +- [ ] **Step 1: Add structural model schema types** + +In `types.ts`, add after `BuildableTable`: + +```ts +export type BuildableTableColumns<T extends BuildableTable> = + T extends { readonly _columnType: infer C } + ? C extends Record<string, unknown> + ? C + : never + : never + +export type EncryptedFromBuildableTable<T, Table extends BuildableTable> = { + [K in keyof T]: [K] extends [keyof BuildableTableColumns<Table>] + ? null extends T[K] + ? Encrypted | null + : Encrypted + : T[K] +} +``` + +This must use the table's existing `_columnType` brand, not `build().columns`. `build()` intentionally returns `Record<string, ColumnSchema>`, which erases literal keys and would mark every model field as encrypted. Keep existing `EncryptedFromSchema` for v2 backward compatibility. + +- [ ] **Step 2: Update client model method signatures** + +In `encryption/index.ts`, change: + +```ts +encryptModel< + T extends Record<string, unknown>, + S extends EncryptedTableColumn = EncryptedTableColumn, +>( + input: T, + table: EncryptedTable<S>, +): EncryptModelOperation<EncryptedFromSchema<T, S>> +``` + +to: + +```ts +encryptModel< + T extends Record<string, unknown>, + Table extends BuildableTable, +>( + input: T, + table: Table, +): EncryptModelOperation<EncryptedFromBuildableTable<T, Table>> +``` + +Change `bulkEncryptModels` similarly: + +```ts +bulkEncryptModels< + T extends Record<string, unknown>, + Table extends BuildableTable, +>( + input: Array<T>, + table: Table, +): BulkEncryptModelsOperation<EncryptedFromBuildableTable<T, Table>> +``` + +Add imports for `BuildableTable` and `EncryptedFromBuildableTable`. + +- [ ] **Step 3: Update helper and operation table types** + +In all listed files, replace: + +```ts +EncryptedTable<EncryptedTableColumn> +``` + +with: + +```ts +BuildableTable +``` + +For imports, remove v2 schema table imports and import `BuildableTable` from `@/types`. + +Affected functions/properties: + +```ts +prepareFieldsForEncryption(..., table: BuildableTable) +encryptModelFields(..., table: BuildableTable) +encryptModelFieldsWithLockContext(..., table: BuildableTable) +prepareBulkModelsForOperation(..., table?: BuildableTable) +bulkEncryptModels(..., table: BuildableTable) +bulkEncryptModelsWithLockContext(..., table: BuildableTable) +EncryptModelOperation.table +EncryptModelOperation.constructor table +EncryptModelOperation.getOperation().table +BulkEncryptModelsOperation.table +BulkEncryptModelsOperation.constructor table +BulkEncryptModelsOperation.getOperation().table +``` + +- [ ] **Step 4: Add model type tests for v3 tables** + +In `schema-v3.test-d.ts`, add: + +```ts +it('encryptModel and bulkEncryptModels infer encrypted fields from v3 tables', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + active: encryptedBoolColumn('active'), + }) + const client = {} as EncryptionClient + + const encryptedOne = client.encryptModel( + { id: 'u1', email: 'alice@example.com', active: true, untouched: 42 }, + users, + ) + expectTypeOf(encryptedOne).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + active: Encrypted + untouched: number + }> + >() + + const encryptedMany = client.bulkEncryptModels( + [{ id: 'u1', email: 'alice@example.com', active: true }], + users, + ) + expectTypeOf(encryptedMany).toEqualTypeOf< + import('@/encryption').BulkEncryptModelsOperation< + { + id: string + email: Encrypted + active: Encrypted + } + > + >() +}) +``` + +Add nullable and v2 re-pinning cases: + +```ts +it('v3 encryptModel preserves unrelated and nullable fields', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: null as string | null, untouched: 42 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted | null + untouched: number + }> + >() +}) + +it('v2 encryptModel inference still preserves non-schema fields after widening', () => { + const users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: 'alice@example.com', age: 30 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + age: number + }> + >() +}) +``` + +- [ ] **Step 5: Run targeted type tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected: PASS. Existing v2 model typing should remain accepted. + +--- + +### Task 7: Add Runtime Client Tests For Representative v3 Domains + +**Files:** +- Modify: `packages/stack/__tests__/schema-v3-client.test.ts` + +- [ ] **Step 1: Expand schema with representative domains** + +Replace the current `users` schema with: + +```ts +const users = encryptedTable('schema_v3_client_users', { + email: encryptedTextSearchColumn('email'), + age: encryptedInt4OrdColumn('age'), + nickname: encryptedTextEqColumn('nickname'), + body: encryptedTextMatchColumn('body'), + notes: encryptedTextColumn('notes'), + active: encryptedBoolColumn('active'), + externalId: encryptedInt8Column('external_id'), + createdOn: encryptedDateColumn('created_on'), + occurredAt: encryptedTimestamptzColumn('occurred_at'), +}) +``` + +- [ ] **Step 2: Add env-gated storage-only encryption tests** + +Add: + +```ts +it('encrypts and decrypts storage-only v3 columns', async () => { + const encryptedText = unwrapResult( + await protectClient.encrypt('private note', { + table: users, + column: users.notes, + }), + ) + expect(encryptedText).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'notes' }, + v: 2, + }) + expect(encryptedText).toHaveProperty('c') + expect(encryptedText).not.toHaveProperty('hm') + expect(encryptedText).not.toHaveProperty('bf') + expect(encryptedText).not.toHaveProperty('ob') + expect(unwrapResult(await protectClient.decrypt(encryptedText))).toBe('private note') + + const encryptedBool = unwrapResult( + await protectClient.encrypt(true, { + table: users, + column: users.active, + }), + ) + expect(encryptedBool).toHaveProperty('c') + expect(unwrapResult(await protectClient.decrypt(encryptedBool))).toBe(true) +}, 30000) +``` + +- [ ] **Step 3: Add representative query tests** + +Add: + +```ts +it('encrypts equality and order query terms for typed v3 columns', async () => { + const equalityTerm = unwrapResult( + await protectClient.encryptQuery('ada', { + table: users, + column: users.nickname, + }), + ) + expect(equalityTerm).toHaveProperty('hm') + expect(equalityTerm).not.toHaveProperty('c') + + const orderTerm = unwrapResult( + await protectClient.encryptQuery(37, { + table: users, + column: users.age, + queryType: 'orderAndRange', + }), + ) + expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).not.toHaveProperty('c') +}, 30000) +``` + +- [ ] **Step 4: Add `text_match`, bigint, and Date live checks** + +Add: + +```ts +it('encrypts free-text terms for text_match columns', async () => { + const encrypted = unwrapResult( + await protectClient.encrypt('Ada Lovelace wrote notes', { + table: users, + column: users.body, + }), + ) + expect(encrypted).toHaveProperty('c') + expect(encrypted).toHaveProperty('bf') + expect(encrypted).not.toHaveProperty('hm') + expect(encrypted).not.toHaveProperty('ob') + + const matchTerm = unwrapResult( + await protectClient.encryptQuery('Lovelace', { + table: users, + column: users.body, + queryType: 'freeTextSearch', + }), + ) + expect(matchTerm).toHaveProperty('bf') + expect(matchTerm).not.toHaveProperty('c') +}, 30000) + +it('round-trips representative bigint and date-like v3 storage domains', async () => { + const int8Encrypted = unwrapResult( + await protectClient.encrypt(1234567890123456789n, { + table: users, + column: users.externalId, + }), + ) + expect(unwrapResult(await protectClient.decrypt(int8Encrypted))).toBe(1234567890123456789n) + + const day = new Date('2026-07-01T00:00:00.000Z') + const dateEncrypted = unwrapResult( + await protectClient.encrypt(day, { + table: users, + column: users.createdOn, + }), + ) + expect(unwrapResult(await protectClient.decrypt(dateEncrypted))).toEqual(day) +}, 30000) +``` + +- [ ] **Step 5: Run without credentials to verify skip behavior** + +Run: + +```bash +env -u CS_WORKSPACE_CRN -u CS_CLIENT_ID -u CS_CLIENT_KEY -u CS_CLIENT_ACCESS_KEY pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-client.test.ts +``` + +Expected: PASS with suite skipped; no module-load throw. + +- [ ] **Step 6: Run with credentials when available** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-client.test.ts +``` + +Expected: +- If `CS_*` env vars are missing: PASS skipped. +- If `CS_*` env vars are present: PASS all live tests. + +--- + +### Task 8: Preserve And Broaden Postgres v3 Tests Safely + +**Files:** +- Modify: `packages/stack/__tests__/schema-v3-pg.test.ts` + +- [ ] **Step 1: Keep `text_search` Postgres tests unchanged unless they fail** + +Preserve: + +```ts +const LIVE_EQL_V3_PG_ENABLED = Boolean( + process.env.DATABASE_URL && + process.env.CS_WORKSPACE_CRN && + process.env.CS_CLIENT_ID && + process.env.CS_CLIENT_KEY && + process.env.CS_CLIENT_ACCESS_KEY, +) +const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip +``` + +- [ ] **Step 2: Add one representative typed-column table when fixture supports it** + +Before adding tests, run: + +```bash +rg "CREATE DOMAIN|CREATE TYPE" packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql | rg "int4_ord|text_eq|bool" +``` + +Expected: output includes `eql_v3.int4_ord`, `eql_v3.text_eq`, and `eql_v3.bool`. + +If those exact domains are present, add a second schema: + +```ts +const typedTable = encryptedTable('protect_ci_v3_typed_domains', { + age: encryptedInt4OrdColumn('age'), + nickname: encryptedTextEqColumn('nickname'), + active: encryptedBoolColumn('active'), +}) +``` + +and create: + +```sql +CREATE TABLE IF NOT EXISTS protect_ci_v3_typed_domains ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + age eql_v3.int4_ord NOT NULL, + nickname eql_v3.text_eq NOT NULL, + active eql_v3.bool NOT NULL, + test_run_id TEXT NOT NULL +) +``` + +- [ ] **Step 3: Add representative PG roundtrip/query test if fixture supports domains** + +Add: + +```ts +it('round-trips and queries representative typed v3 domains', async () => { + const age = unwrapResult(await protectClient.encrypt(37, { table: typedTable, column: typedTable.age })) + const nickname = unwrapResult(await protectClient.encrypt('ada', { table: typedTable, column: typedTable.nickname })) + const active = unwrapResult(await protectClient.encrypt(true, { table: typedTable, column: typedTable.active })) + + const [inserted] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) + VALUES ( + ${sql.json(age as postgres.JSONValue)}::eql_v3.int4_ord, + ${sql.json(nickname as postgres.JSONValue)}::eql_v3.text_eq, + ${sql.json(active as postgres.JSONValue)}::eql_v3.bool, + ${TEST_RUN_ID} + ) + RETURNING id + ` + + const ageTerm = unwrapResult(await protectClient.encryptQuery(30, { + table: typedTable, + column: typedTable.age, + queryType: 'orderAndRange', + })) as postgres.JSONValue + + const rows = await sql<{ id: number }[]>` + SELECT id + FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(age) >= eql_v3.ore_block_256(${sql.json(ageTerm)}::jsonb) + ` + + expect(rows.map((row) => row.id)).toContain(inserted.id) +}, 30000) +``` + +If the fixture does not expose these exact domains, do not add this test. Keep existing `text_search` PG coverage as the live SQL proof for this pass. + +- [ ] **Step 4: Verify skip and live behavior** + +Run: + +```bash +env -u DATABASE_URL pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-pg.test.ts +``` + +Expected: PASS skipped; no module-load throw. + +Run with DB/env only when available: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-pg.test.ts +``` + +Expected: +- Missing env: PASS skipped. +- Present env and fixture installed: PASS. + +--- + +### Task 9: Fix Or Isolate `wasm-inline-column-name.test.ts` Import Resolution + +**Files:** +- Modify: `packages/stack/vitest.config.ts` +- Modify only if needed: `packages/stack/__tests__/wasm-inline-column-name.test.ts` + +- [ ] **Step 1: Reproduce current failure** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/wasm-inline-column-name.test.ts +``` + +Expected current failure: Vitest cannot resolve or load `@cipherstash/protect-ffi/wasm-inline`. + +- [ ] **Step 2: Prefer local mocks for this unit test** + +At the top of `wasm-inline-column-name.test.ts`, before importing `../src/wasm-inline`, add: + +```ts +import { vi } from 'vitest' + +vi.mock('@cipherstash/auth/wasm-inline', () => ({ + AccessKeyStrategy: { + create: vi.fn(), + }, +})) + +vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ + decrypt: vi.fn(), + encrypt: vi.fn(), + isEncrypted: vi.fn(), + newClient: vi.fn(), +})) +``` + +This test only covers `getColumnName`; it does not need real WASM. + +- [ ] **Step 3: Add Vitest alias only if mocking does not resolve import evaluation** + +Inspect package path: + +```bash +node -p "require.resolve('@cipherstash/protect-ffi/package.json')" +``` + +Inspect exports: + +```bash +node -p "JSON.stringify(require('@cipherstash/protect-ffi/package.json').exports, null, 2)" +``` + +If the export points to a concrete JS file and mocks are insufficient, add an alias in `vitest.config.ts` using the actual export path. + +- [ ] **Step 4: Run the focused test** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/wasm-inline-column-name.test.ts +``` + +Expected: PASS. + +--- + +### Task 10: Validate Package Export And Build Compatibility + +**Files:** +- Modify only if failing: `packages/stack/package.json` +- Modify only if failing: `packages/stack/tsup.config.ts` + +- [ ] **Step 1: Confirm `schema/v3` remains exported for ESM and CJS** + +Run: + +```bash +node -p "const p=require('./packages/stack/package.json'); p.exports['./schema/v3']" +``` + +Expected includes both: + +```text +import.types ./dist/schema/v3/index.d.ts +import.default ./dist/schema/v3/index.js +require.types ./dist/schema/v3/index.d.cts +require.default ./dist/schema/v3/index.cjs +``` + +- [ ] **Step 2: Confirm tsup includes v3 entry** + +Run: + +```bash +rg "src/schema/v3/index.ts" packages/stack/tsup.config.ts +``` + +Expected: one match in the main dual-format entry list. + +- [ ] **Step 3: Build stack package** + +Run: + +```bash +pnpm --filter @cipherstash/stack build +``` + +Expected: PASS. `dist/schema/v3/index.d.ts`, `.d.cts`, `.js`, and `.cjs` are generated. + +- [ ] **Step 4: Verify CJS require remains supported** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/cjs-require.test.ts +``` + +Expected: PASS. If no v3 CJS assertion exists, add: + +```ts +const schemaV3 = require('@cipherstash/stack/schema/v3') +expect(typeof schemaV3.encryptedTextSearchColumn).toBe('function') +expect(typeof schemaV3.encryptedInt4Column).toBe('function') +``` + +--- + +### Task 11: Add Changeset + +**Files:** +- Create: `.changeset/eql-v3-typed-schema.md` + +- [ ] **Step 1: Add changeset file** + +Create: + +```md +--- +'@cipherstash/stack': minor +--- + +Add EQL v3 schema builders for all generated SQL domains under `@cipherstash/stack/schema/v3`, including explicit query capability metadata and v3 table support in model encryption helpers. +``` + +- [ ] **Step 2: Verify changeset format** + +Run: + +```bash +pnpm changeset status +``` + +Expected: command reports a pending minor changeset for `@cipherstash/stack`. + +--- + +### Task 12: Full Verification Pass + +**Files:** +- All changed files above. + +- [ ] **Step 1: Run formatter/fixer** + +Run: + +```bash +pnpm run code:fix +``` + +Expected: PASS; files may be formatted. + +- [ ] **Step 2: Run focused stack tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3.test.ts __tests__/schema-v3-client.test.ts __tests__/schema-v3-pg.test.ts __tests__/wasm-inline-column-name.test.ts +``` + +Expected: +- Unit tests PASS. +- Live tests PASS skipped when env vars are missing. +- No module-load failures when env vars are missing. + +- [ ] **Step 3: Run type tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected: PASS. + +- [ ] **Step 4: Run package build** + +Run: + +```bash +pnpm --filter @cipherstash/stack build +``` + +Expected: PASS. + +- [ ] **Step 5: Run package test suite if credentials are available** + +Run: + +```bash +pnpm --filter @cipherstash/stack test +``` + +Expected: +- With credentials: PASS, including live tests. +- Without credentials: PASS for unit tests and env-gated live suites skipped. If unrelated existing live tests fail due to missing `CS_*`, record that explicitly in the final implementation notes. + +--- + +## Commit Plan + +- [ ] Commit 1: `test: cover eql v3 typed schema domains` + - Include `schema-v3.test.ts` and `schema-v3.test-d.ts` failing tests. +- [ ] Commit 2: `feat: add eql v3 domain builders` + - Include `schema/v3/index.ts`. +- [ ] Commit 3: `feat: support v3 tables in model encryption` + - Include `types.ts`, encryption client/helper/operation files, and model type tests. +- [ ] Commit 4: `test: stabilize v3 client and wasm-inline coverage` + - Include live test updates and Vitest/WASM test fix. +- [ ] Commit 5: `changeset: document eql v3 typed schema` + - Include `.changeset/eql-v3-typed-schema.md`. + +--- + +## Self-Review + +**Spec coverage:** This plan keeps v3 isolated under `@cipherstash/stack/schema/v3`, exports one builder per EQL v3 domain, preserves v2 schema, adds explicit `getQueryCapabilities()` and `isQueryable()`, tightens `BuildableQueryColumn`, widens model helpers structurally, preserves `text_search` byte-equivalent config, keeps `EncryptConfig` free of v3 metadata, env-gates live tests, and addresses `wasm-inline` Vitest resolution. + +**Review-driven corrections:** The design intentionally uses a full literal domain definition generic (`eqlType`, `castAs`, and capabilities), not a capability-only generic, because empty TypeScript subclasses are not nominal. Model encryption inference intentionally reads table keys from the existing `_columnType` brand, not `build().columns`, because the structural `BuildableTable.build()` contract erases literal keys to `Record<string, ColumnSchema>`. + +**Placeholder scan:** No task uses unresolved placeholders. Conditional Postgres expansion is tied to a concrete `rg` command and an explicit keep-existing-tests outcome. + +**Type consistency:** Public capability names are consistently `equality`, `orderAndRange`, and `freeTextSearch`. Queryable v3 columns require `isQueryable(): true`; storage-only columns return `false` and remain accepted by `encrypt` through `BuildableColumn`. diff --git a/docs/superpowers/specs/2026-06-30-eql-v3-text-search-schema-design.md b/docs/superpowers/specs/2026-06-30-eql-v3-text-search-schema-design.md new file mode 100644 index 00000000..da27a884 --- /dev/null +++ b/docs/superpowers/specs/2026-06-30-eql-v3-text-search-schema-design.md @@ -0,0 +1,328 @@ +# EQL v3 Schema DSL — `text_search` (Increment 1) + +**Date:** 2026-06-30 +**Status:** Approved (design) +**Package:** `@cipherstash/stack` +**Scope:** Authoring DSL + encrypt-config emission for the `eql_v3.text_search` +concrete type, **plus** a backward-compatible structural widening of the public +client types so v3 builders are first-class with the client API (`Encryption`, +`encrypt`, `decrypt`, `encryptQuery`). DDL and query-dialect work are explicitly +deferred (see Non-goals). + +--- + +## Goal + +Begin the EQL v3 version of the encryption SDK. EQL v3 removes the generic +"encrypted" concept in favour of **concrete types that carry their own +capabilities**. The first concrete type is `eql_v3.text_search`. + +Today: + +```ts +const users = encryptedTable('users', { + email: encryptedColumn('email').equality().freeTextSearch(), +}) +``` + +v3: + +```ts +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), +}) +``` + +Because the concrete type carries capability, the capability-enabling calls +(`.equality()`, `.orderAndRange()`, `.freeTextSearch()` *as enablers*) disappear. +What remains is **tuning** of the match index: + +```ts +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email').freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }), +}) +``` + +## Background — what `eql_v3.text_search` is + +Source of truth: +`<eql-v3-worktree>/release/cipherstash-encrypt-v3.sql`. + +`eql_v3.text_search` is a Postgres `CREATE DOMAIN ... AS jsonb` whose `CHECK` +requires an object containing `v, i, c, hm, ob, bf` (with `v = '2'`). The domain +defines **all three** index extractors as functions: + +- `eql_v3.eq_term(text_search)` → equality (`hm` = hmac) +- `eql_v3.ord_term(text_search)` → order/range (`ob` = ore blocks) +- `eql_v3.match_term(text_search)` → free-text match (`bf` = bloom filter) + +So `text_search` is the **full-capability** text type: equality + order + match. +EQL v3 also defines narrower text domains (`text`, `text_eq`, `text_match`, +`text_ord(_ore)`) and full families for `int*`/`float*`/`date`/`bool`/`numeric`/ +`timestamptz`/`json` — all out of scope for this increment. + +### The load-bearing fact: the payload is identical + +The encrypted envelope a v2 column produces (`{ v, i, c, hm, ob, bf }`) already +satisfies the `eql_v3.text_search` domain `CHECK`. Therefore: + +- A v2 `eql_v2_encrypted` column built with equality + order + match can be + retyped to `eql_v3.text_search` with **no re-encryption** — a future + `ALTER COLUMN ... TYPE` is a `jsonb → jsonb` metadata flip. +- The native cipherstash-client (`@cipherstash/protect-ffi` `newClient`) needs + **no changes**: the `EncryptConfig` it receives is unchanged. +- The SDK's **runtime** encrypt/decrypt/query path needs no changes either — it + is purely structural (it only reads `column.getName()`, `column.build()`, + `table.tableName`, `table.build().columns`; there is no `instanceof` on that + path). + +What this increment *does* change is the SDK's **public TYPES**: today they are +typed against the v2 `EncryptedTable<EncryptedTableColumn>` / `EncryptedColumn` +classes, which are nominal (private fields), so the separate v3 +`EncryptedTextSearchColumn` class is not assignable to them. To make v3 builders +work with the client (not just emit a config), the public client types are +**widened to a structural contract** in this increment (see "Client integration" +below). The widening is purely additive — existing v2 usage is unaffected. + +## Architecture & location + +- New module: `packages/stack/src/schema/v3/` (own `index.ts`; split into + focused files if it grows). +- New export subpath: `@cipherstash/stack/schema/v3` (added to `package.json` + `exports` + `tsup`/build entry as needed). +- The v2 schema module (`packages/stack/src/schema/index.ts`) keeps its runtime + behavior and existing exported symbol shapes; the only permitted edit there is + a backward-compatible **widening** of `buildEncryptConfig`'s parameter type to + the shared structural table contract (it already only calls `.build()`). +- v3 builders emit the existing `ColumnSchema` / `EncryptConfig` shape, so the + encryption client, payload, encrypt/decrypt, and query paths work at runtime + with **zero runtime changes**. Client integration at the **type** level is + achieved by widening the public types (next section), not by a runtime rewrite. + +## Public API + +```ts +import { encryptedTable, encryptedTextSearchColumn } from '@cipherstash/stack/schema/v3' + +// minimal — capability is carried by the type +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), +}) + +// with match-index tuning +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email').freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }), +}) +``` + +- `encryptedTextSearchColumn(name)` → `EncryptedTextSearchColumn`. The concrete + type **inherently enables equality + order + match**. There are no + capability-enabling methods. +- `.freeTextSearch(opts?)` is **tuning only** — it overrides the match-index + parameters. It never "enables" a capability (match is always on for this type). +- `encryptedTable(tableName, columns)` (v3) accepts v3 column builders and + assembles `{ tableName, columns }`. +- `buildEncryptConfig(...tables)` (v3) assembles an `EncryptConfig` (`v: 1`). + +> Naming note: v3 `encryptedTable` / `buildEncryptConfig` intentionally shadow the +> v2 names but live on the `/v3` subpath, so an importer picks the model by import +> path, not by symbol name. + +## Client integration (in scope) + +v3 builders must be **accepted by the client API**, not merely emit a config. The +runtime already works (structural — see "load-bearing fact"); the blocker is the +public TYPES. This increment widens them to a shared **structural contract** so +both v2 and v3 builders satisfy them: + +```ts +// minimal structural shapes — exact members verified against the client's +// actual usage (column.getName/build, table.tableName/build): +interface BuildableColumn { getName(): string; build(): ColumnSchema } +interface BuildableTable { + tableName: string + build(): { tableName: string; columns: Record<string, ColumnSchema> } +} +// Query path is NARROWER: it must reject non-queryable EncryptedField (no +// indexes). A v2 EncryptedColumn qualifies nominally; a v3 queryable concrete +// type qualifies via getEqlType(); EncryptedField is excluded. +type BuildableQueryColumn = + | EncryptedColumn + | (BuildableColumn & { getEqlType(): string }) +``` + +Widened surfaces (in `packages/stack/src/types.ts`) — note the **storage vs query split**: + +- `EncryptionClientConfig.schemas` → `AtLeastOneCsTable<BuildableTable>` +- `EncryptOptions.column` / `.table` → `BuildableColumn` / `BuildableTable` — + the STORAGE path (`encrypt`) accepts columns AND nested fields. +- `SearchTerm` / `QueryTermBase.column` → `BuildableQueryColumn`; `.table` → + `BuildableTable` — the QUERY path (`encryptQuery`) accepts only queryable + columns, so a `BuildableQueryColumn` excludes `EncryptedField` (which the + nominal `EncryptedColumn` type rejected and must keep rejecting). +- Internally, the query-only index-inference helpers + (`inferIndexType`/`validateIndexType`/`resolveIndexType`) also take + `BuildableQueryColumn` (verified reached only from the `encryptQuery` path). + +Plus `buildEncryptConfig`'s parameter is widened to `BuildableTable` (pure +widening; it only calls `.build()`). + +**v3 keeps its own `EncryptedTable` class** (it needs a different column +constraint and a simpler `build()` than v2's nested-field/ste_vec logic). Both +the v2 and v3 table/column classes satisfy the structural contract, which is what +lets a single widened type accept either. + +**Backward compatibility:** widening only — existing v2 tables/columns still +satisfy the new types (a regression type-test asserts this). The **generic +schema-aware model methods** (`encryptModel<S extends EncryptedTableColumn>` / +`bulkEncryptModels`) are **left unchanged** so v2's field-level inference +(`InferPlaintext`, `EncryptedFields`, `EncryptedFromSchema`, the +`EncryptedTable<T> & T` accessor) is preserved. v3 support for the model methods +(its columns don't satisfy `EncryptedTableColumn`) is a **future increment**. + +**Acceptance (these must type-check with v3 builders):** +`Encryption({ schemas: [v3users] })`, `client.encrypt(v, { table: v3users, column: +v3users.email })`, `client.decrypt(...)` round-trip, and +`client.encryptQuery(v, { table: v3users, column: v3users.email })`. Plus the +storage/query split: a v2 `encryptedField` is `encrypt`-able but a `@ts-expect-error` +proves it is NOT `encryptQuery`-able, and a v2 `EncryptedColumn` stays queryable. + +> Discriminator follow-up: `getEqlType()` distinguishes queryable v3 types today +> only because the one v3 type shipping (`text_search`) is queryable. If a future +> v3 *non-queryable* type also carries `getEqlType()`, switch the query-path +> discriminator to a queryability-specific marker. Not blocking for this increment. + +## `build()` output — pinned to v2 + +`encryptedTextSearchColumn('email').build()` emits exactly: + +```ts +{ + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, +} +``` + +Notes: + +- **`cast_as: 'string'`**, not `'text'`. The native cipherstash-client receives + the SDK-facing value verbatim; `toEqlCastAs` ('string' → 'text') is applied + only on the `wasm-inline.ts` SQL-generation path, not the `newClient` path. +- Defaults mirror v2's `freeTextSearch()` **exactly**: ngram-3, downcase filter, + `k = 6`, `m = 2048`, `include_original = true` (note: `true`, matching the v2 + builder default, not the zod-schema default of `false`). +- `unique.token_filters` defaults to `[]` (case-sensitive equality, matching v2). +- `.freeTextSearch(opts)` overrides on a per-field basis using the same merge + semantics as v2 (each provided key replaces the default; omitted keys keep the + default). + +**The guarantee:** this output is byte-identical to + +```ts +encryptedColumn('email').equality().orderAndRange().freeTextSearch().build() +``` + +and a test asserts that equality directly (see Testing). This is what makes +"swap the column type and it just works" true at the config level. + +## v3 metadata for later increments + +`EncryptedTextSearchColumn` records its concrete domain name — +`'eql_v3.text_search'` — exposed via the `getEqlType()` method (method only, no +property getter, matching the v2 builder convention). + +- `build()` (the encrypt config) does **not** include `eqlType`; the wire config + stays identical to v2. +- The name is metadata that the *future* DDL and query-dialect increments read + (per-column Postgres type, `eql_v3.eq_term(...)` lowering). Recording it now + gives those increments a hook without changing today's config. + +## Type inference + +v3 `InferPlaintext` / `InferEncrypted` mirror v2: + +- `InferPlaintext<typeof users>` → `{ email: string }` +- `InferEncrypted<typeof users>` → `{ email: Encrypted }` + +## Non-goals (deferred to follow-up increments) + +> Note: "widen the public client types" was previously implied as out of scope +> ("zero client changes"). It is now **in scope** for this increment (see Client +> integration). The items below remain deferred. + +- **v3 support in the generic schema-aware model methods** (`encryptModel` / + `bulkEncryptModels` field-level inference) — v3 columns don't satisfy the v2 + `EncryptedTableColumn` constraint those generics use. Single-value + `encrypt`/`decrypt`/`encryptQuery` + `Encryption()` config DO work in this + increment; model-method inference for v3 is a follow-up. +- **v3 columns through the WASM-inline entry** (`wasm-inline.ts`) — known + boundary. `getColumnName()` (`src/wasm-inline.ts:314-320`) runtime-checks + `instanceof EncryptedColumn || instanceof EncryptedField` and throws otherwise, + so a v3 column passed to the WASM-inline client would throw at runtime. The + type widening still compiles (the `instanceof` guard narrows the wider union) + and this path is outside the scoped typecheck, so it is a documented deferred + boundary, not a regression. The batch-2 "no `instanceof`" / structural-runtime + claim is scoped to the native `operations/*.ts` path. +- **Per-column DDL type emission** — deriving each column's Postgres type from + its v3 builder. v2 hard-codes one native type (`eql_v2_encrypted`); v3 needs a + per-column type (`eql_v3.text_search`, etc.). Net-new, touches every adapter. +- **v2 → v3 transition tooling** — `ALTER TABLE ... ALTER COLUMN ... TYPE + eql_v3.text_search` and retiring the now-redundant `eql_v2_configuration` / + `add_search_config` rows for the column. +- **v3 query dialect** — `eql_v3.eq_term(col) = eql_v3.eq_term($1::eql_v3.text_search)` + in drizzle / supabase operator lowering. +- **Other v3 concrete types** — `int*`, `float*`, `date`, `bool`, `numeric`, + `timestamptz`, `text_eq`/`text_ord`, `json`, etc. The module is structured so + these slot in later (a domain → config mapping per type). +- **Nested `encryptedField` / structured columns** for v3 — only top-level + `text_search` columns ship in increment 1. + +## Testing + +- **Config-equivalence (load-bearing):** + `encryptedTextSearchColumn('email').build()` deep-equals + `encryptedColumn('email').equality().orderAndRange().freeTextSearch().build()`. +- **`.freeTextSearch()` override:** each provided opt replaces its default; + omitted opts retain defaults; verify the documented "additional config" example + produces the expected match block. +- **Defaults:** assert the exact default `build()` output above (catches any + silent default drift). +- **`buildEncryptConfig`:** a v3 table assembles into a valid `EncryptConfig` + (`v: 1`) that passes `encryptConfigSchema.parse(...)`. +- **`eqlType` metadata:** `getEqlType()` returns `'eql_v3.text_search'` and is + absent from `build()` output. +- **No shared mutable state:** two columns built independently must not alias — + mutating one column's `build()` output must not affect another's (defaults are + produced per-instance, `build()` returns a fresh clone). +- **Type-level:** `InferPlaintext` / `InferEncrypted` produce the expected shapes. +- **Client integration (type-level):** the acceptance snippets above type-check + with v3 builders, and a regression test asserts v2 tables/columns still satisfy + the widened public types. + +## Open questions + +None blocking. Future increments will decide how `eqlType` threads into DDL and +query lowering, and how the narrower text domains (`text_eq`, `text_match`, +`text_ord`) and other scalar families are expressed in the DSL. diff --git a/packages/stack/__tests__/cjs-require.test.ts b/packages/stack/__tests__/cjs-require.test.ts index 1a79ec46..fd08afe5 100644 --- a/packages/stack/__tests__/cjs-require.test.ts +++ b/packages/stack/__tests__/cjs-require.test.ts @@ -83,6 +83,24 @@ describe('CJS consumers can require the built bundles', () => { it('discovers at least the public entry points', () => { expect(cjsEntries).toContain('dist/index.cjs') expect(cjsEntries).toContain('dist/encryption/index.cjs') + expect(cjsEntries).toContain('dist/schema/v3/index.cjs') + }) + + it('exposes v3 schema builders from the CJS bundle', () => { + const v3Bundle = path.join(distDir, 'schema', 'v3', 'index.cjs') + const script = [ + `const v3 = require(${JSON.stringify(v3Bundle)})`, + `const required = ['encryptedTextSearchColumn', 'encryptedInt4Column', 'encryptedBoolColumn', 'encryptedTimestamptzColumn']`, + `const missing = required.filter((k) => typeof v3[k] !== 'function')`, + `if (missing.length > 0) { throw new Error('missing v3 CJS exports: ' + missing.join(', ')) }`, + ].join('\n') + + expect(() => + execFileSync(process.execPath, ['-e', script], { + cwd: packageRoot, + stdio: 'pipe', + }), + ).not.toThrow() }) it.each( diff --git a/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql b/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql new file mode 100644 index 00000000..331a3813 --- /dev/null +++ b/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql @@ -0,0 +1,29308 @@ +--! @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. +--! +--! 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. + +--! @brief Drop existing EQL v3 schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3 CASCADE; + +--! @brief Create EQL v3 schema +--! @note Houses the encrypted-domain type families +CREATE SCHEMA eql_v3; + +--! @file v3/sem/ore_block_256/types.sql +--! @brief ORE block index-term types (eql_v3 SEM). +--! +--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types +--! (design D1/D3). The eql_v2 originals are unchanged. + +--! @brief ORE block term type for Order-Revealing Encryption +--! +--! Composite type representing a single ORE block term. Stores encrypted data +--! as bytea that enables range comparisons without decryption. +CREATE TYPE eql_v3.ore_block_256_term AS ( + bytes bytea +); + + +--! @brief ORE block index term type for range queries +--! +--! Composite type containing an array of ORE block terms. The array is stored +--! in the 'ob' field of encrypted data payloads. +--! +--! @note Transient type used only during query execution. +CREATE TYPE eql_v3.ore_block_256 AS ( + terms eql_v3.ore_block_256_term[] +); + +--! @file v3/crypto.sql +--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! +--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! closure lives under src/v3/. Enables the pgcrypto extension which provides +--! cryptographic functions used by the eql_v3 ORE comparison path. +--! +--! Installs pgcrypto into the `extensions` schema (Supabase convention) to +--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto +--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing +--! install in `public` keeps working — and a pre-existing install anywhere else +--! will be rejected at install time. The body is idempotent +--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it +--! alongside the eql_v2 copy in a combined install is safe. +--! +--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() + +--! @brief Create extensions schema (Supabase convention) +CREATE SCHEMA IF NOT EXISTS extensions; + +--! @brief Enable pgcrypto extension and validate its schema +DO $$ +DECLARE + pgcrypto_schema name; +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN + CREATE EXTENSION pgcrypto WITH SCHEMA extensions; + END IF; + + SELECT n.nspname INTO pgcrypto_schema + FROM pg_extension e + JOIN pg_namespace n ON n.oid = e.extnamespace + WHERE e.extname = 'pgcrypto'; + + IF pgcrypto_schema = 'extensions' THEN + -- expected location, nothing to say + NULL; + ELSIF pgcrypto_schema = 'public' THEN + RAISE NOTICE + 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' + 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; + ELSE + RAISE EXCEPTION + 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' + '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' + 'runtime. Relocate the extension before installing EQL: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', + pgcrypto_schema; + END IF; +END $$; + +--! @file v3/common.sql +--! @brief Common utility functions for the self-contained eql_v3 surface. +--! +--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! one transitive helper it needs without reaching into another schema. The +--! eql_v2 original is unchanged. + +--! @brief Convert JSONB hex array to bytea array +--! @internal +--! +--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. +--! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! +--! @param val jsonb JSONB array of hex-encoded strings +--! @return bytea[] Array of decoded binary values +--! +--! @note Returns NULL if input is JSON null +--! @note Each array element is hex-decoded to bytea +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the set-returning `jsonb_array_elements_text` for an array, so a +--! non-array JSON scalar returns NULL here instead of raising "cannot extract +--! elements from a scalar". Both callers only ever pass an array or JSON null +--! (`val->'ob'`), so the divergence is unreachable in practice; JSON null and +--! empty array still return NULL exactly as before. +CREATE FUNCTION eql_v3.jsonb_array_to_bytea_array(val jsonb) +RETURNS bytea[] + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ( + SELECT array_agg(decode(value::text, 'hex')::bytea) + FROM jsonb_array_elements_text(val) AS value + ) + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path.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)'; + +--! @file v3/sem/hmac_256/types.sql +--! @brief HMAC-SHA256 index term type (eql_v3 SEM) +--! +--! Domain type representing HMAC-SHA256 hash values. Used for exact-match +--! encrypted searches. The hash is stored in the 'hm' field of encrypted data +--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is +--! unchanged. +--! +--! @note Transient type used only during query execution. +CREATE DOMAIN eql_v3.hmac_256 AS text; + +--! @file v3/sem/bloom_filter/types.sql +--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. + +--! @brief Bloom-filter index term: a bit array stored as smallint[]. +--! +--! Backs the `match` capability (`@>` / `<@`) on `eql_v3.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[]; + +--! @file v3/scalars/functions.sql +--! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! +--! Per-domain wrapper functions live in src/v3/scalars/<T>/. +--! Blockers in those files delegate to encrypted_domain_unsupported_bool +--! so every domain raises a uniform domain-specific error rather than +--! letting an unsupported operator fall through to native jsonb +--! behaviour. + +--! @brief Shared blocker helper. Raises 'operator X is not supported +--! for TYPE' so unsupported domain operators surface a clear +--! error rather than fall through to native jsonb behaviour. +--! @param type_name Domain type name (eql_v3.<T>*) +--! @param operator_name Operator symbol (=, <, @>, ->, etc.) +--! @return boolean (never returns; always raises) +CREATE FUNCTION eql_v3.encrypted_domain_unsupported_bool(type_name text, operator_name text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning jsonb. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! native operators whose result is jsonb (#>, -, #-, ||), so composed +--! expressions resolve and the body raises rather than failing earlier +--! with a misleading 'operator does not exist' on a boolean result. +--! @param type_name Domain type name (eql_v3.<T>*) +--! @param operator_name Operator symbol (#>, -, #-, ||, etc.) +--! @return jsonb (never returns; always raises) +CREATE FUNCTION eql_v3.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning text. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! the native #>> operator whose result is text. +--! @param type_name Domain type name (eql_v3.<T>*) +--! @param operator_name Operator symbol (#>>) +--! @return text (never returns; always raises) +CREATE FUNCTION eql_v3.encrypted_domain_unsupported_text(type_name text, operator_name text) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/sem/ore_block_256/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.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 +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; + +--! @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.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 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 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 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; + + 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 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) + + 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.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; + + 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.compare_ore_block_256_term(a[1], b[1]); + + 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; + + RETURN cmp_result; + END +$$ LANGUAGE plpgsql; + + +--! @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; + +--! @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. + +--! @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 +$$; + +--! @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 +$$; + +--! @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 +$$; + +--! @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 +$$; + +--! @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 +$$; + +--! @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 +$$; + + +--! @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.<T>_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 +); + +--! @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 +); + +--! @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 +); + +--! @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 +); + +--! @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 +); + +--! @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 +); + +--! @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.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 +$$; + + +--! @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 +$$; + +--! @file v3/sem/bloom_filter/functions.sql +--! @brief Extractor for the eql_v3 Bloom-filter SEM index term. +--! +--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column +--! overloads are intentionally omitted — the eql_v3 scalar domains extract from +--! the jsonb payload directly via a cast to the domain. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. +--! +--! @param val jsonb The encrypted payload. +--! @return boolean True when the `bf` key is present and non-null. +--! +--! @internal Defined for parity with the eql_v3 SEM index-term predicates +--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by +--! the extractor below, which gates on value-shape inline, nor by the generated +--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept +--! as the canonical presence test for callers that need one. +CREATE FUNCTION eql_v3.has_bloom_filter(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract the Bloom-filter index term from a jsonb payload. +--! +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so the functional GIN index built on `eql_v3.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. + +--! @file v3/scalars/int4/int4_types.sql +--! @brief Encrypted-domain types for int4. + +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; + + --! @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; + + --! @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' + ); + END IF; + + --! @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' + ); + END IF; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_ord_functions.sql +--! @brief Functions for eql_v3.int4_ord. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int4_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.int4_ord) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) = 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 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int4_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.int4_ord) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) <> 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 +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int4_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.int4_ord) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) < 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 +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int4_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.int4_ord) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) <= 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 +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int4_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.int4_ord) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) > 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 +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int4_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.int4_ord) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.int4_ord) >= 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 +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a jsonb +--! @param selector eql_v3.int4_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int4_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int4_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int4_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int4_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int4_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int4_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int4_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int4_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int4_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b eql_v3.int4_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord, b eql_v3.int4_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a eql_v3.int4_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord. +--! @param a jsonb +--! @param b eql_v3.int4_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int4_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_ord_operators.sql +--! @brief Operators for eql_v3.int4_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int4_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4_ord, RIGHTARG = eql_v3.int4_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_eq_functions.sql +--! @brief Functions for eql_v3.int4_eq. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int4_eq, b eql_v3.int4_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.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int4_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.int4_eq) $$; + +--! @brief Operator wrapper for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.int4_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int4_eq, b eql_v3.int4_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.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int4_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.int4_eq) $$; + +--! @brief Operator wrapper for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.int4_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a jsonb +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b eql_v3.int4_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4_eq. +--! @param a eql_v3.int4_eq +--! @param b jsonb +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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 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; + +--! @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 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; + +--! @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 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 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 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; + +--! @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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamptz/timestamptz_types.sql +--! @brief Encrypted-domain types for timestamptz. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.timestamptz. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamptz' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamptz 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.timestamptz_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamptz_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamptz_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.timestamptz_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamptz_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamptz_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 Encrypted domain eql_v3.timestamptz_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamptz_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamptz_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. + +--! @file encrypted_domain/timestamptz/timestamptz_ord_ore_functions.sql +--! @brief Functions for eql_v3.timestamptz_ord_ore. + +--! @brief Index extractor for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @return eql_v3.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamptz_ord_ore) +RETURNS eql_v3.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz_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.timestamptz_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz_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.timestamptz_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz_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.timestamptz_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz_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.timestamptz_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz_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.timestamptz_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz_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.timestamptz_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param selector text +--! @return eql_v3.timestamptz_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz_ord_ore, selector text) +RETURNS eql_v3.timestamptz_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param selector integer +--! @return eql_v3.timestamptz_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz_ord_ore, selector integer) +RETURNS eql_v3.timestamptz_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamptz_ord_ore +--! @return eql_v3.timestamptz_ord_ore +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.timestamptz_ord_ore) +RETURNS eql_v3.timestamptz_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamptz_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamptz_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.timestamptz_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamptz_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamptz_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamptz_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamptz_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamptz_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamptz_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamptz_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b eql_v3.timestamptz_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz_ord_ore, b eql_v3.timestamptz_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a eql_v3.timestamptz_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamptz_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_ord_ore_operators.sql +--! @brief Operators for eql_v3.timestamptz_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = eql_v3.timestamptz_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_eq_functions.sql +--! @brief Functions for eql_v3.timestamptz_eq. + +--! @brief Index extractor for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @return eql_v3.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.timestamptz_eq) +RETURNS eql_v3.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_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.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz_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.timestamptz_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamptz_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_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.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz_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.timestamptz_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamptz_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamptz_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param selector text +--! @return eql_v3.timestamptz_eq +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz_eq, selector text) +RETURNS eql_v3.timestamptz_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param selector integer +--! @return eql_v3.timestamptz_eq +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz_eq, selector integer) +RETURNS eql_v3.timestamptz_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamptz_eq +--! @return eql_v3.timestamptz_eq +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.timestamptz_eq) +RETURNS eql_v3.timestamptz_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamptz_eq +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamptz_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.timestamptz_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamptz_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamptz_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamptz_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamptz_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamptz_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamptz_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamptz_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b eql_v3.timestamptz_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz_eq, b eql_v3.timestamptz_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a eql_v3.timestamptz_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_eq. +--! @param a jsonb +--! @param b eql_v3.timestamptz_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamptz_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_ord_functions.sql +--! @brief Functions for eql_v3.timestamptz_ord. + +--! @brief Index extractor for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @return eql_v3.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamptz_ord) +RETURNS eql_v3.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz_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.timestamptz_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz_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.timestamptz_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz_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.timestamptz_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz_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.timestamptz_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz_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.timestamptz_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz_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.timestamptz_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamptz_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamptz_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param selector text +--! @return eql_v3.timestamptz_ord +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz_ord, selector text) +RETURNS eql_v3.timestamptz_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param selector integer +--! @return eql_v3.timestamptz_ord +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz_ord, selector integer) +RETURNS eql_v3.timestamptz_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamptz_ord +--! @return eql_v3.timestamptz_ord +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.timestamptz_ord) +RETURNS eql_v3.timestamptz_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamptz_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamptz_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.timestamptz_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamptz_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamptz_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamptz_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamptz_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamptz_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamptz_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamptz_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b eql_v3.timestamptz_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz_ord, b eql_v3.timestamptz_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a eql_v3.timestamptz_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz_ord. +--! @param a jsonb +--! @param b eql_v3.timestamptz_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamptz_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_ord_operators.sql +--! @brief Operators for eql_v3.timestamptz_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = eql_v3.timestamptz_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/int2/int2_types.sql +--! @brief Encrypted-domain types for int2. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.int2. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'int2' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.int2 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.int2_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'int2_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.int2_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.int2_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'int2_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.int2_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 Encrypted domain eql_v3.int2_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'int2_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.int2_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. + +--! @file encrypted_domain/int2/int2_ord_ore_functions.sql +--! @brief Functions for eql_v3.int2_ord_ore. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b eql_v3.int2_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @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) $$; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b eql_v3.int2_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int2_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord_ore'; 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 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int2_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.int2_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int2_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int2_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int2_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int2_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int2_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int2_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int2_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2_ord_ore'; 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 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord_ore, b eql_v3.int2_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a eql_v3.int2_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int2_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_ord_functions.sql +--! @brief Functions for eql_v3.int2_ord. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @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) $$; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord, b eql_v3.int2_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int2_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int2_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord, b eql_v3.int2_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int2_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int2_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int2_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a jsonb +--! @param selector eql_v3.int2_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int2_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int2_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int2_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int2_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int2_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int2_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int2_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b eql_v3.int2_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord, b eql_v3.int2_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a eql_v3.int2_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int2_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2_ord. +--! @param a jsonb +--! @param b eql_v3.int2_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_ord_operators.sql +--! @brief Operators for eql_v3.int2_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int2_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2_ord, RIGHTARG = eql_v3.int2_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_functions.sql +--! @brief Functions for eql_v3.int2. + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.eq(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.eq(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.neq(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.neq(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.lt(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.lt(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.lte(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int2, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int2, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param selector eql_v3.int2 +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int2) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int2, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int2, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int2, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int2, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int2, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int2, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int2, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int2, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int2, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b eql_v3.int2 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int2, b eql_v3.int2) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a eql_v3.int2 +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int2, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int2. +--! @param a jsonb +--! @param b eql_v3.int2 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int2) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int2'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_ord_ore_operators.sql +--! @brief Operators for eql_v3.int2_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = eql_v3.int2_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/float8/float8_types.sql +--! @brief Encrypted-domain types for float8. + +DO $$ +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' + ); + END IF; + + --! @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 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' + ); + END IF; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_ord_ore_functions.sql +--! @brief Functions for eql_v3.float8_ord_ore. + +--! @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 +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) $$; + +--! @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.lt(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.lt(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.lt(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.lte(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.lte(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.lte(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.gt(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.gt(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.gt(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.gte(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.gte(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.gte(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 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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_ord_ore_operators.sql +--! @brief Operators for eql_v3.float8_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = eql_v3.float8_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_ord_functions.sql +--! @brief Functions for eql_v3.float8_ord. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.float8_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.float8_ord) $$; + +--! @brief Operator wrapper for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float8_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) = 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 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.float8_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.float8_ord) $$; + +--! @brief Operator wrapper for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float8_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) <> 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 +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float8_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.float8_ord) $$; + +--! @brief Operator wrapper for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float8_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) < 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 +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float8_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.float8_ord) $$; + +--! @brief Operator wrapper for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float8_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) <= 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 +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float8_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.float8_ord) $$; + +--! @brief Operator wrapper for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float8_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) > 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 +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float8_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.float8_ord) $$; + +--! @brief Operator wrapper for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float8_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float8_ord) >= 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 +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float8_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float8_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float8_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a jsonb +--! @param selector eql_v3.float8_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float8_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.float8_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.float8_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.float8_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.float8_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.float8_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.float8_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.float8_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float8_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.float8_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b eql_v3.float8_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float8_ord, b eql_v3.float8_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a eql_v3.float8_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float8_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_ord. +--! @param a jsonb +--! @param b eql_v3.float8_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float8_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_functions.sql +--! @brief Functions for eql_v3.float8. + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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 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 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 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 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; + +--! @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 Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b eql_v3.float8 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a jsonb +--! @param b eql_v3.float8 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b eql_v3.float8 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a jsonb +--! @param b eql_v3.float8 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b text[] +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b text[] +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.float8. +--! @param a eql_v3.float8 +--! @param b jsonpath +--! @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 jsonpath +--! @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; + +--! @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 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; + +--! @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 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 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; + +--! @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; + +--! @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. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for eql_v3.date_ord_ore. + +--! @brief Index extractor for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @return eql_v3.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord_ore) +RETURNS eql_v3.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.date_ord_ore, selector text) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.date_ord_ore, selector integer) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.date_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.date_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.date_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.date_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.date_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for eql_v3.date_eq. + +--! @brief Index extractor for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @return eql_v3.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.date_eq) +RETURNS eql_v3.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3."->"(a eql_v3.date_eq, selector text) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3."->"(a eql_v3.date_eq, selector integer) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.date_eq) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for eql_v3.date. + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return eql_v3.date +CREATE FUNCTION eql_v3."->"(a eql_v3.date, selector text) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return eql_v3.date +CREATE FUNCTION eql_v3."->"(a eql_v3.date, selector integer) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return eql_v3.date +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.date) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.date, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for eql_v3.date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.numeric. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.numeric_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.numeric_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.numeric_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ore. + +--! @brief Index extractor for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @return eql_v3.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord_ore) +RETURNS eql_v3.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.numeric_ord_ore, selector text) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.numeric_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for eql_v3.numeric_eq. + +--! @brief Index extractor for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @return eql_v3.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.numeric_eq) +RETURNS eql_v3.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.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; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @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; + +--! @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.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bool/bool_types.sql +--! @brief Encrypted-domain types for bool. + +DO $$ +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' + ); + END IF; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bool/bool_functions.sql +--! @brief Functions for eql_v3.bool. + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.bool, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.bool, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param selector eql_v3.bool +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.bool) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.bool, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.bool, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.bool, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.bool, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.bool, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.bool, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.bool, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.bool, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.bool, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.bool, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.bool, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b eql_v3.bool +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.bool, b eql_v3.bool) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a eql_v3.bool +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.bool, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bool. +--! @param a jsonb +--! @param b eql_v3.bool +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.bool) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bool'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/int8/int8_types.sql +--! @brief Encrypted-domain types for int8. + +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; + + --! @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; + + --! @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; + + --! @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. + +--! @file encrypted_domain/int8/int8_functions.sql +--! @brief Functions for eql_v3.int8. + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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 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; + +--! @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 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; + +--! @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 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 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 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 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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_ord_functions.sql +--! @brief Functions for eql_v3.int8_ord. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int8_ord, b eql_v3.int8_ord) +RETURNS boolean 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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int8_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.int8_ord) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8_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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int8_ord, b eql_v3.int8_ord) +RETURNS boolean 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 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int8_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.int8_ord) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8_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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int8_ord, b eql_v3.int8_ord) +RETURNS boolean 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 +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int8_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.int8_ord) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int8_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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int8_ord, b eql_v3.int8_ord) +RETURNS boolean 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 +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int8_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.int8_ord) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int8_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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int8_ord, b eql_v3.int8_ord) +RETURNS boolean 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 +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int8_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.int8_ord) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int8_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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int8_ord, b eql_v3.int8_ord) +RETURNS boolean 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 +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int8_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.int8_ord) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int8_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) $$; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_ord +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_ord +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b eql_v3.int8_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; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord. +--! @param a eql_v3.int8_ord +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord. +--! @param a jsonb +--! @param b eql_v3.int8_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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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 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; + +--! @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. + +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'bf' + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '2' + ); + END IF; +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) $$; + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3."->"(a eql_v3.text_ord, selector text) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3."->"(a eql_v3.text_ord, selector integer) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.text_ord) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.text_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for eql_v3.text_ord_ore. + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3.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) $$; + +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.text_ord_ore, selector text) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3."->"(a eql_v3.text_ord_ore, selector integer) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_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) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3."->"(a eql_v3.text_match, selector text) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3."->"(a eql_v3.text_match, selector integer) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.text_match) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_match, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for eql_v3.text_search. + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3.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) $$; + +--! @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) $$; + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3."->"(a eql_v3.text_search, selector text) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3."->"(a eql_v3.text_search, selector integer) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.text_search) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_search, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for eql_v3.text_eq. + +--! @brief Index extractor for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @return eql_v3.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.text_eq) +RETURNS eql_v3.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3."->"(a eql_v3.text_eq, selector text) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3."->"(a eql_v3.text_eq, selector integer) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.text_eq) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.text_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.text_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.text_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.text_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.text_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/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. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.text_ord, 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 = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.text_ord, 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 = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_ord, 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; + + --! @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. + +--! @file encrypted_domain/float4/float4_ord_ore_functions.sql +--! @brief Functions for eql_v3.float4_ord_ore. + +--! @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) $$; + +--! @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) $$; + +--! @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 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 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 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 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) $$; + +--! @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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a eql_v3.float4_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.float4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(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 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.lte(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a eql_v3.float4_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.float4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(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 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.gt(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a eql_v3.float4_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.float4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(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 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.gte(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a eql_v3.float4_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(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 Operator wrapper for eql_v3.float4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.float4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(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 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; + +--! @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.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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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. + +--! @file encrypted_domain/float4/float4_eq_functions.sql +--! @brief Functions for eql_v3.float4_eq. + +--! @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) $$; + +--! @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) $$; + +--! @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) $$; + +--! @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) $$; + +--! @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) $$; + +--! @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) $$; + +--! @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) $$; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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 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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float4/float4_ord_functions.sql +--! @brief Functions for eql_v3.float4_ord. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.float4_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.float4_ord) $$; + +--! @brief Operator wrapper for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) = 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 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.float4_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.float4_ord) $$; + +--! @brief Operator wrapper for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) <> 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 +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float4_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.float4_ord) $$; + +--! @brief Operator wrapper for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) < 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 +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float4_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.float4_ord) $$; + +--! @brief Operator wrapper for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) <= 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 +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float4_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.float4_ord) $$; + +--! @brief Operator wrapper for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) > 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 +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float4_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.float4_ord) $$; + +--! @brief Operator wrapper for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float4_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.float4_ord) >= 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 +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float4_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float4_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float4_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a jsonb +--! @param selector eql_v3.float4_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float4_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.float4_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.float4_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.float4_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.float4_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.float4_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.float4_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.float4_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float4_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.float4_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b eql_v3.float4_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float4_ord, b eql_v3.float4_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a eql_v3.float4_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float4_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4_ord. +--! @param a jsonb +--! @param b eql_v3.float4_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float4_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float4/float4_ord_ore_operators.sql +--! @brief Operators for eql_v3.float4_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_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, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_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, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_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, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_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, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_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, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_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 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = eql_v3.float4_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float4_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float4/float4_ord_operators.sql +--! @brief Operators for eql_v3.float4_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4_ord, RIGHTARG = eql_v3.float4_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4_ord, RIGHTARG = jsonb, + 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, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + 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, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + 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, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + 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, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_ord, + 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 +); + +--! @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 +); + +--! @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.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 +$$; + +COMMENT ON FUNCTION eql_v3.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.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.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.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 + + 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.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; + + 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; + + 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.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/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.ste_vec_entry — a single sv element (returned by `->`). +--! - eql_v3.ste_vec_query — a containment needle (sv elements, no ciphertext). + +--! @brief Validate a single SteVec entry payload. +--! @internal +--! @param val jsonb Candidate entry payload. +--! @return boolean True when `val` is an sv entry with string `s`, string `c`, +--! and exactly one string deterministic term (`hm` XOR `oc`). +CREATE FUNCTION eql_v3.is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'oc')) + OR + (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; + +--! @brief Validate a SteVec containment query payload. +--! @internal +--! @param val jsonb Candidate query payload. +--! @return boolean True when `val` is `{"sv":[...]}` and every element carries +--! string `s`, no ciphertext, and exactly one string term (`hm` XOR +--! `oc`). +CREATE FUNCTION eql_v3.is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ) +$$; + +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 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 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 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.ste_vec_entry AS jsonb + CHECK ( + eql_v3.is_valid_ste_vec_entry_payload(VALUE) + ); + +--! @brief Domain type for an STE-vec containment needle. +--! +--! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index +--! term but **never** a ciphertext (`c`). Each element must carry `s` and +--! exactly one deterministic term (`hm` XOR `oc`). Typing the needle this way +--! stops selector-only needles from casting and matching every row via bare +--! `jsonb @>`. +--! +--! @note Construct from inline JSON via the DOMAIN cast: +--! `'{"sv":[{"s":"<sel>","hm":"<hm>"}]}'::eql_v3.ste_vec_query`. +--! @see eql_v3.to_ste_vec_query +CREATE DOMAIN eql_v3.ste_vec_query AS jsonb + CHECK ( + eql_v3.is_valid_ste_vec_query_payload(VALUE) + ); + +--! @brief Convert an eql_v3.json to a ste_vec_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.ste_vec_query Query-shaped needle, sv elements normalised. +--! @see eql_v3.ste_vec_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) + RETURNS eql_v3.ste_vec_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.ste_vec_query +$$; + +CREATE CAST (eql_v3.json AS eql_v3.ste_vec_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @file v3/jsonb/functions.sql +--! @brief Extractors, containment engine, and path/array functions for the +--! eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! `selector` parameters here are *encrypted-side* selector hashes — the +--! deterministic hash the crypto layer emits in the `s` field of each sv +--! element. Plaintext JSONPaths are never accepted at runtime. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @brief Extract metadata (i, v) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return jsonb Metadata object with `i` and `v` fields. +CREATE FUNCTION eql_v3.meta_data(val jsonb) + RETURNS jsonb + IMMUTABLE STRICT PARALLEL SAFE + LANGUAGE SQL +AS $$ + SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); +$$; + +COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS + 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; + +--! @brief Extract ciphertext (c) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text Base64-encoded ciphertext. +--! @throws Exception if `c` is absent. +CREATE FUNCTION eql_v3.ciphertext(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'c' THEN + RETURN val->>'c'; + END IF; + RAISE 'Expected a ciphertext (c) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @brief Extract selector (s) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text The selector value. +--! @throws Exception if `s` is absent. +CREATE FUNCTION eql_v3.selector(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 's' THEN + RETURN val->>'s'; + END IF; + RAISE 'Expected a selector index (s) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK +--! guarantees `s` is present, so this is a simple field access. +--! @param entry eql_v3.ste_vec_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry eql_v3.ste_vec_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, oc)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for eql_v3.ste_vec_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 ste_vec_entry. +--! +--! @param entry eql_v3.ste_vec_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry eql_v3.ste_vec_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) +------------------------------------------------------------------------------ + +--! @brief Extract CLLW ORE index term from a ste_vec entry. +--! +--! `oc` is only ever present on an sv element, never at a root encrypted value, +--! so the typed overload accepts eql_v3.ste_vec_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry eql_v3.ste_vec_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.ste_vec_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 Check if a ste_vec entry contains a CLLW ORE index term. +--! @param entry eql_v3.ste_vec_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.ste_vec_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.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. +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. +CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; + +--! @brief Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! oc)). This collapses the v2 hm/oc CASE: under the XOR contract both terms +--! are deterministic and byte-disjoint, so either one is a valid equality +--! discriminator and a single byte comparison is correct. +--! +--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and oc byte +--! distributions never collide at a given selector. The crypto layer configures +--! a selector for eq XOR ordered, so both sides of a real comparison carry the +--! same term type; and an oc value carries a leading domain-tag byte an hm never +--! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` +--! CASE, this collapse would wrongly match an hm needle against an oc leaf if +--! their hex bytes were ever identical — which the contract prevents. The +--! negative-containment test guards against regression. +--! +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b is found in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + _a jsonb; + BEGIN + result := false; + + FOR idx IN 1..array_length(a, 1) LOOP + _a := a[idx]; + result := result OR ( + eql_v3.selector(_a) = eql_v3.selector(b) + AND eql_v3.eq_term(_a::eql_v3.ste_vec_entry) = eql_v3.eq_term(b::eql_v3.ste_vec_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @brief Does encrypted value `a` contain all sv elements of `b`? +--! +--! Empty b is always contained. Each element of b must match selector + eq_term +--! in some element of a. +--! +--! @param a eql_v3.json Container. +--! @param b eql_v3.json Elements to find. +--! @return boolean True if all elements of b are contained in a. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a eql_v3.json, b eql_v3.json) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + sv_a jsonb[]; + sv_b jsonb[]; + _b jsonb; + BEGIN + sv_a := eql_v3.ste_vec(a); + sv_b := eql_v3.ste_vec(b); + + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; + + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; + + result := true; + + FOR idx IN 1..array_length(sv_b, 1) LOOP + _b := sv_b[idx]; + result := result AND eql_v3.ste_vec_contains(sv_a, _b); + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ + +--! @brief Query encrypted JSONB for sv elements matching `selector`. +--! +--! Returns one ste_vec_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.ste_vec_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF eql_v3.ste_vec_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.ste_vec_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.ste_vec_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a selector path exists in encrypted JSONB. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to test. +--! @return boolean True if a matching element exists. +CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT EXISTS ( + SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; + +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return eql_v3.ste_vec_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS eql_v3.ste_vec_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.ste_vec_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.is_ste_vec_array(val) THEN + sv := eql_v3.ste_vec(val); + RETURN array_length(sv, 1); + END IF; + + RAISE 'cannot get array length of a non-array'; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract elements of an encrypted JSONB array as rows. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF eql_v3.ste_vec_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.ste_vec_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; + + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::eql_v3.ste_vec_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.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; + + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template + +DROP FUNCTION IF EXISTS eql_v3.version(); + +--! @file v3/version.sql +--! @brief EQL version reporting (self-contained eql_v3 surface) +--! +--! This file is auto-generated from src/v3/version.template during build. +--! The 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 +--! -- 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 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'; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_ord_aggregates.sql +--! @brief Aggregates for eql_v3.int4_ord. + +--! @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 +LANGUAGE plpgsql IMMUTABLE 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.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, + 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 +LANGUAGE plpgsql IMMUTABLE 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.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, + 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; + +--! @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 Unsupported operator blocker for eql_v3.int4. +--! @param a jsonb +--! @param b eql_v3.int4 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b eql_v3.int4 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a jsonb +--! @param b eql_v3.int4 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b eql_v3.int4 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a jsonb +--! @param b eql_v3.int4 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b text[] +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b text[] +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b jsonpath +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int4. +--! @param a eql_v3.int4 +--! @param b jsonpath +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_eq_operators.sql +--! @brief Operators for eql_v3.int4_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4_eq, RIGHTARG = eql_v3.int4_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_ord_ore_functions.sql +--! @brief Functions for eql_v3.int4_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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean 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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int4_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) $$; + +--! @brief Operator wrapper for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int4_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) $$; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int4_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int4_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int4_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 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int4_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int4_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int4_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.int4_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int4_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int4_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int4_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int4_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int4_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int4_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int4_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int4_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int4_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int4_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int4_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 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord_ore, b eql_v3.int4_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a eql_v3.int4_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int4_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int4_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int4_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int4_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int4_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. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_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, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_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, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_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, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_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, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_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, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_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 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = eql_v3.int4_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_operators.sql +--! @brief Operators for eql_v3.int4. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int4, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int4, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int4, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int4, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int4, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int4, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int4, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int4, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int4, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int4, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int4, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4, RIGHTARG = eql_v3.int4 +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int4, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int4 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int4/int4_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.int4_ord_ore. + +--! @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 $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @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 +); + +--! @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; + 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 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.timestamptz_ord_ore. + +--! @brief State function for min on eql_v3.timestamptz_ord_ore. +--! @param state eql_v3.timestamptz_ord_ore +--! @param value eql_v3.timestamptz_ord_ore +--! @return eql_v3.timestamptz_ord_ore +CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.timestamptz_ord_ore, value eql_v3.timestamptz_ord_ore) +RETURNS eql_v3.timestamptz_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.timestamptz_ord_ore. +--! @param input eql_v3.timestamptz_ord_ore +--! @return eql_v3.timestamptz_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.timestamptz_ord_ore) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.timestamptz_ord_ore, + combinefunc = eql_v3.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamptz_ord_ore. +--! @param state eql_v3.timestamptz_ord_ore +--! @param value eql_v3.timestamptz_ord_ore +--! @return eql_v3.timestamptz_ord_ore +CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.timestamptz_ord_ore, value eql_v3.timestamptz_ord_ore) +RETURNS eql_v3.timestamptz_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.timestamptz_ord_ore. +--! @param input eql_v3.timestamptz_ord_ore +--! @return eql_v3.timestamptz_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.timestamptz_ord_ore) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.timestamptz_ord_ore, + combinefunc = eql_v3.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_functions.sql +--! @brief Functions for eql_v3.timestamptz. + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.timestamptz, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.timestamptz) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param selector text +--! @return eql_v3.timestamptz +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz, selector text) +RETURNS eql_v3.timestamptz IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param selector integer +--! @return eql_v3.timestamptz +CREATE FUNCTION eql_v3."->"(a eql_v3.timestamptz, selector integer) +RETURNS eql_v3.timestamptz IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param selector eql_v3.timestamptz +--! @return eql_v3.timestamptz +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.timestamptz) +RETURNS eql_v3.timestamptz IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.timestamptz, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param selector eql_v3.timestamptz +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.timestamptz) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.timestamptz, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.timestamptz, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.timestamptz, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.timestamptz, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.timestamptz, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.timestamptz, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.timestamptz, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.timestamptz, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.timestamptz, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b eql_v3.timestamptz +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz, b eql_v3.timestamptz) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a eql_v3.timestamptz +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.timestamptz, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamptz. +--! @param a jsonb +--! @param b eql_v3.timestamptz +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.timestamptz) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamptz'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_eq_operators.sql +--! @brief Operators for eql_v3.timestamptz_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = eql_v3.timestamptz_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_ord_aggregates.sql +--! @brief Aggregates for eql_v3.timestamptz_ord. + +--! @brief State function for min on eql_v3.timestamptz_ord. +--! @param state eql_v3.timestamptz_ord +--! @param value eql_v3.timestamptz_ord +--! @return eql_v3.timestamptz_ord +CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.timestamptz_ord, value eql_v3.timestamptz_ord) +RETURNS eql_v3.timestamptz_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.timestamptz_ord. +--! @param input eql_v3.timestamptz_ord +--! @return eql_v3.timestamptz_ord +CREATE AGGREGATE eql_v3.min(eql_v3.timestamptz_ord) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.timestamptz_ord, + combinefunc = eql_v3.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamptz_ord. +--! @param state eql_v3.timestamptz_ord +--! @param value eql_v3.timestamptz_ord +--! @return eql_v3.timestamptz_ord +CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.timestamptz_ord, value eql_v3.timestamptz_ord) +RETURNS eql_v3.timestamptz_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.timestamptz_ord. +--! @param input eql_v3.timestamptz_ord +--! @return eql_v3.timestamptz_ord +CREATE AGGREGATE eql_v3.max(eql_v3.timestamptz_ord) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.timestamptz_ord, + combinefunc = eql_v3.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamptz/timestamptz_operators.sql +--! @brief Operators for eql_v3.timestamptz. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.timestamptz, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.timestamptz, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.timestamptz, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz, RIGHTARG = eql_v3.timestamptz +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.timestamptz, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamptz +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_eq_functions.sql +--! @brief Functions for eql_v3.int2_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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.int2_eq. +--! @param a eql_v3.int2_eq +--! @param b eql_v3.int2_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int2_eq, b eql_v3.int2_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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int2_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) $$; + +--! @brief Operator wrapper for eql_v3.int2_eq. +--! @param a jsonb +--! @param b eql_v3.int2_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int2_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 Operator wrapper for eql_v3.int2_eq. +--! @param a eql_v3.int2_eq +--! @param b eql_v3.int2_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int2_eq, b eql_v3.int2_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 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int2_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) $$; + +--! @brief Operator wrapper for eql_v3.int2_eq. +--! @param a jsonb +--! @param b eql_v3.int2_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int2_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; + +--! @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.gte(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.gte(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.gte(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.contains(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.contains(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.contains(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.contained_by(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.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) +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; $$ +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. +--! @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 +--! @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 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 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int2, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int2, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int2, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int2, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int2, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int2, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int2, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int2, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2, RIGHTARG = eql_v3.int2 +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_eq_operators.sql +--! @brief Operators for eql_v3.int2_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int2_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int2_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int2_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2_eq, RIGHTARG = eql_v3.int2_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int2_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int2_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int2/int2_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.int2_ord_ore. + +--! @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 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 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 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. + +--! @file encrypted_domain/float8/float8_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.float8_ord_ore. + +--! @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; +$$; + +--! @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 +); + +--! @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; +$$; + +--! @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 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_eq_functions.sql +--! @brief Functions for eql_v3.float8_eq. + +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @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) $$; + +--! @brief Operator wrapper for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @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) $$; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float8_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float8_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float8_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float8_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float8_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float8_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float8_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float8_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param selector eql_v3.float8_eq +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float8_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.float8_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.float8_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.float8_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.float8_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.float8_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.float8_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.float8_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float8_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float8_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float8_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.float8_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b eql_v3.float8_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float8_eq, b eql_v3.float8_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a eql_v3.float8_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float8_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float8_eq. +--! @param a jsonb +--! @param b eql_v3.float8_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float8_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float8_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_ord_operators.sql +--! @brief Operators for eql_v3.float8_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8_ord, RIGHTARG = eql_v3.float8_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_ord_aggregates.sql +--! @brief Aggregates for eql_v3.float8_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 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 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 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 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_operators.sql +--! @brief Operators for eql_v3.float8. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float8, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float8, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float8, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float8, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float8, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float8, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float8, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float8, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8, RIGHTARG = eql_v3.float8 +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float8/float8_eq_operators.sql +--! @brief Operators for eql_v3.float8_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float8_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float8_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8_eq, RIGHTARG = eql_v3.float8_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float8_eq +); +-- 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; + +--! @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; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for eql_v3.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for eql_v3.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ore. + +--! @brief State function for min on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS eql_v3.date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ore) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS eql_v3.date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ore) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for eql_v3.date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); +-- 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 +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3.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 +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for eql_v3.numeric_ord. + +--! @brief Index extractor for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @return eql_v3.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) +RETURNS eql_v3.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3."->"(a eql_v3.numeric_ord, selector text) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3."->"(a eql_v3.numeric_ord, selector integer) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.numeric_ord) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.numeric_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.numeric_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.numeric_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.numeric_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for eql_v3.numeric. + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3."->"(a eql_v3.numeric, selector text) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3."->"(a eql_v3.numeric, selector integer) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3."->"(a jsonb, selector eql_v3.numeric) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.numeric, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for eql_v3.numeric_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_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; +$$; + +--! @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 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 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. + +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for eql_v3.numeric. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for eql_v3.numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord. + +--! @brief State function for min on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS eql_v3.numeric_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS eql_v3.numeric_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bool/bool_operators.sql +--! @brief Operators for eql_v3.bool. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.bool, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.bool, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.bool, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.bool, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.bool, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.bool, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.bool, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.bool, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.bool, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.bool, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.bool, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.bool, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.bool, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.bool, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.bool, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.bool, RIGHTARG = eql_v3.bool +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.bool, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bool +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_operators.sql +--! @brief Operators for eql_v3.int8. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int8, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int8, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int8, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int8, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int8, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int8, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int8, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int8, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8, RIGHTARG = eql_v3.int8 +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_eq_functions.sql +--! @brief Functions for eql_v3.int8_eq. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int8_eq, b eql_v3.int8_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.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int8_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.int8_eq) $$; + +--! @brief Operator wrapper for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.int8_eq) = 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 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int8_eq, b eql_v3.int8_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.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int8_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.int8_eq) $$; + +--! @brief Operator wrapper for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.int8_eq) <> 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 +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contains(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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(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; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param selector eql_v3.int8_eq +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int8_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int8_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int8_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int8_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int8_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int8_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int8_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int8_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int8_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int8_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int8_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int8_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b eql_v3.int8_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int8_eq, b eql_v3.int8_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a eql_v3.int8_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int8_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_eq. +--! @param a jsonb +--! @param b eql_v3.int8_eq +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int8_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_ord_ore_functions.sql +--! @brief Functions for eql_v3.int8_ord_ore. + +--! @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 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ore_block_256(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 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean 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_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.int8_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.int8_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.int8_ord_ore) +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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean 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_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.int8_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.int8_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.int8_ord_ore) +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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean 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_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.int8_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.int8_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.int8_ord_ore) +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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean 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_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.int8_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.int8_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.int8_ord_ore) +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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean 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_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.int8_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.int8_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.int8_ord_ore) +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) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean 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_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.int8_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.int8_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.int8_ord_ore) +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) $$; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.int8_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.int8_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.int8_ord_ore'; 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 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.int8_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.int8_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.int8_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.int8_ord_ore +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.int8_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.int8_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.int8_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.int8_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.int8_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.int8_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.int8_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.int8_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.int8_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.int8_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.int8_ord_ore'; 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 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int8_ord_ore, b eql_v3.int8_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a eql_v3.int8_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.int8_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.int8_ord_ore. +--! @param a jsonb +--! @param b eql_v3.int8_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.int8_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.int8_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_ord_operators.sql +--! @brief Operators for eql_v3.int8_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int8_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8_ord, RIGHTARG = eql_v3.int8_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_ord_ore_operators.sql +--! @brief Operators for eql_v3.int8_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = eql_v3.int8_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_ord_ore +); +-- 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 +LANGUAGE plpgsql IMMUTABLE 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.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, + 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 +LANGUAGE plpgsql IMMUTABLE 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.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, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_ord_aggregates.sql +--! @brief Aggregates for eql_v3.int8_ord. + +--! @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 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 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 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 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/int8/int8_eq_operators.sql +--! @brief Operators for eql_v3.int8_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.int8_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.int8_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.int8_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8_eq, RIGHTARG = eql_v3.int8_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.int8_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.int8_eq +); +-- 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; + +--! @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 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 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 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; + +--! @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 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 Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @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; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @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 jsonpath +--! @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; +-- 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 +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +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 +); + +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 = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +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 = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for eql_v3.text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for eql_v3.text_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); +-- 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 +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3.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 +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3.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; +$$; + +--! @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 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 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 +); +-- 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 +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for eql_v3.text_search. + +--! @brief State function for min on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS eql_v3.text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( + sfunc = eql_v3.min_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS eql_v3.text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( + sfunc = eql_v3.max_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float4/float4_eq_operators.sql +--! @brief Operators for eql_v3.float4_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float4_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float4_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float4_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float4_eq, RIGHTARG = eql_v3.float4_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float4_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float4/float4_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.float4_ord_ore. + +--! @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 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 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 +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/float4/float4_functions.sql +--! @brief Functions for eql_v3.float4. + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.float4, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.float4) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @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; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float4, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3."->>"(a eql_v3.float4, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param selector eql_v3.float4 +--! @return text +CREATE FUNCTION eql_v3."->>"(a jsonb, selector eql_v3.float4) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3."?"(a eql_v3.float4, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?|"(a eql_v3.float4, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3."?&"(a eql_v3.float4, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@?"(a eql_v3.float4, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3."@@"(a eql_v3.float4, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#>"(a eql_v3.float4, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3."#>>"(a eql_v3.float4, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float4, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float4, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."-"(a eql_v3.float4, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3."#-"(a eql_v3.float4, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b eql_v3.float4 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float4, b eql_v3.float4) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a eql_v3.float4 +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a eql_v3.float4, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.float4. +--! @param a jsonb +--! @param b eql_v3.float4 +--! @return jsonb +CREATE FUNCTION eql_v3."||"(a jsonb, b eql_v3.float4) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.float4'; 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. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float4, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = eql_v3.float4, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float4, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = eql_v3.float4, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3."?", + LEFTARG = eql_v3.float4, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3."?|", + LEFTARG = eql_v3.float4, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3."?&", + LEFTARG = eql_v3.float4, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3."@?", + LEFTARG = eql_v3.float4, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3."@@", + LEFTARG = eql_v3.float4, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3."#>", + LEFTARG = eql_v3.float4, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3."#>>", + LEFTARG = eql_v3.float4, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3."-", + LEFTARG = eql_v3.float4, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3."#-", + LEFTARG = eql_v3.float4, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float4, RIGHTARG = eql_v3.float4 +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = eql_v3.float4, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.float4 +); + +--! @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.ste_vec_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.ste_vec_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.ste_vec_entry Running extremum. +--! @param value eql_v3.ste_vec_entry Candidate entry. +--! @return eql_v3.ste_vec_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3.ste_vec_entry_min_sfunc( + state eql_v3.ste_vec_entry, + value eql_v3.ste_vec_entry +) +RETURNS eql_v3.ste_vec_entry +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 + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate over eql_v3.ste_vec_entry. +--! @param input eql_v3.ste_vec_entry +--! @return eql_v3.ste_vec_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(eql_v3.ste_vec_entry) ( + sfunc = eql_v3.ste_vec_entry_min_sfunc, + stype = eql_v3.ste_vec_entry, + combinefunc = eql_v3.ste_vec_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.ste_vec_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! entries are skipped, mirroring `ste_vec_entry_min_sfunc` (see the file @note). +--! +--! @param state eql_v3.ste_vec_entry Running extremum. +--! @param value eql_v3.ste_vec_entry Candidate entry. +--! @return eql_v3.ste_vec_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3.ste_vec_entry_max_sfunc( + state eql_v3.ste_vec_entry, + value eql_v3.ste_vec_entry +) +RETURNS eql_v3.ste_vec_entry +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 + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate over eql_v3.ste_vec_entry. +--! @param input eql_v3.ste_vec_entry +--! @return eql_v3.ste_vec_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(eql_v3.ste_vec_entry) ( + sfunc = eql_v3.ste_vec_entry_max_sfunc, + stype = eql_v3.ste_vec_entry, + combinefunc = eql_v3.ste_vec_entry_max_sfunc, + parallel = safe +); + +--! @file v3/jsonb/operators.sql +--! @brief Operators on eql_v3.json and eql_v3.ste_vec_entry. + +------------------------------------------------------------------------------ +-- -> field accessor (returns ste_vec_entry) +------------------------------------------------------------------------------ + +--! @brief -> operator with text selector. +--! +--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged +--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to +--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional +--! index on `eql_v3.eq_term(col -> 'sel')`. +--! +--! @warning The selector operand MUST carry a known type — a text-typed +--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::text`). +--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> text` +--! operator and silently returns native jsonb semantics (a root-key lookup, +--! typically NULL), NOT this operator: PostgreSQL reduces the `eql_v3.json` +--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the +--! native base-type operator wins the exact-match tiebreak. This is intrinsic to +--! the domain type-kind and applies to the native-jsonb blockers too. See +--! the "Typed operands" caveat in docs/reference/json-support.md. +--! +--! @param e eql_v3.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return eql_v3.ste_vec_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) + RETURNS eql_v3.ste_vec_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.ste_vec_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return eql_v3.ste_vec_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) + RETURNS eql_v3.ste_vec_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE + WHEN eql_v3.is_ste_vec_array(e) THEN + -- `->(eql_v3.json, text)` operator is already created earlier in + -- this file, so a bare `e -> 'sv'` would resolve to that selector-lookup + -- operator (searching for an sv entry with selector 'sv') instead of + -- native jsonb array access. Casting to jsonb forces native `->`. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.ste_vec_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- ->> field accessor (alias of -> coerced to text) +------------------------------------------------------------------------------ + +--! @brief ->> operator with text selector. Inlinable alias of -> coerced to +--! text. +--! +--! Intentional v2 parity: this serializes the entire matched ste_vec_entry +--! object as JSON text. It does not decrypt or return scalar plaintext like +--! native `jsonb ->>`. +--! @param e eql_v3.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector text) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector integer) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a eql_v3.json Container. +--! @param b eql_v3.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief @> contains operator with an ste_vec_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.ste_vec_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.ste_vec_query) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.ste_vec_query +); + +--! @brief @> contains operator with a single ste_vec_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.ste_vec_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.ste_vec_entry) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb + @> jsonb_build_object( + 'sv', + jsonb_build_array( + jsonb_strip_nulls( + jsonb_build_object( + 's', b -> 's', + 'hm', b -> 'hm', + 'oc', b -> 'oc' + ) + ) + ) + ) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.ste_vec_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a eql_v3.json Contained value. +--! @param b eql_v3.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with an ste_vec_query LHS. +--! @param a eql_v3.ste_vec_query Query payload. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.ste_vec_query, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.ste_vec_query, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with a ste_vec_entry LHS. +--! @param a eql_v3.ste_vec_entry Single entry. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.ste_vec_entry, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.ste_vec_entry, + RIGHTARG=eql_v3.json +); + +------------------------------------------------------------------------------ +-- ste_vec_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on ste_vec_entry via eq_term (hm-or-oc byte equality). +--! @internal +--! @param a eql_v3.ste_vec_entry Left operand +--! @param b eql_v3.ste_vec_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a eql_v3.ste_vec_entry, b eql_v3.ste_vec_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) +$$; + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.ste_vec_entry, + RIGHTARG = eql_v3.ste_vec_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on ste_vec_entry via eq_term. +--! @internal +--! @param a eql_v3.ste_vec_entry Left operand +--! @param b eql_v3.ste_vec_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a eql_v3.ste_vec_entry, b eql_v3.ste_vec_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) +$$; + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.ste_vec_entry, + RIGHTARG = eql_v3.ste_vec_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on ste_vec_entry via ore_cllw. +--! @internal +--! @param a eql_v3.ste_vec_entry Left operand +--! @param b eql_v3.ste_vec_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a eql_v3.ste_vec_entry, b eql_v3.ste_vec_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.ste_vec_entry, + RIGHTARG = eql_v3.ste_vec_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on ste_vec_entry via ore_cllw. +--! @internal +--! @param a eql_v3.ste_vec_entry Left operand +--! @param b eql_v3.ste_vec_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a eql_v3.ste_vec_entry, b eql_v3.ste_vec_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.ste_vec_entry, + RIGHTARG = eql_v3.ste_vec_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on ste_vec_entry via ore_cllw. +--! @internal +--! @param a eql_v3.ste_vec_entry Left operand +--! @param b eql_v3.ste_vec_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a eql_v3.ste_vec_entry, b eql_v3.ste_vec_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.ste_vec_entry, + RIGHTARG = eql_v3.ste_vec_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on ste_vec_entry via ore_cllw. +--! @internal +--! @param a eql_v3.ste_vec_entry Left operand +--! @param b eql_v3.ste_vec_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a eql_v3.ste_vec_entry, b eql_v3.ste_vec_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.ste_vec_entry, + RIGHTARG = eql_v3.ste_vec_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for eql_v3.json. +--! +--! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on eql_v3.ste_vec_entry only, not on the root +--! document domain. +--! Every OTHER native jsonb operator reachable via domain fallback against the +--! base type jsonb is BLOCKED here so an encrypted column can never silently +--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS +--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. +--! +--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let +--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the +--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! helpers. Each blocker's RETURNS type matches the native operator it shadows +--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a +--! composed expression resolves and the body raises 'operator not supported', +--! rather than failing earlier with a misleading 'operator does not exist' on a +--! boolean intermediate. The bound operator must resolve before native fallback, +--! so the firewall fires. + +--! @brief Blocker: ? (key/element exists). +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b text Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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.jsonb_blocked_exists, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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.jsonb_blocked_exists_any, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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[] +); + +--! @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 +); + +--! @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 +); + +--! @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[] +); + +--! @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[] +); + +--! @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 +); + +--! @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.jsonb_blocked_delete_int, + LEFTARG = eql_v3.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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.jsonb_blocked_delete_array, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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.jsonb_blocked_delete_path, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.jsonb_blocked_concat(a eql_v3.json, b jsonb) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3.jsonb_blocked_concat, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json Right operand (encrypted payload). +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.jsonb_blocked_concat_rhs(a jsonb, b eql_v3.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root eql_v3.json document comparisons. +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b eql_v3.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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 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 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; + +CREATE OPERATOR = ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +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 +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3.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; + +--! @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; + +--! @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; + +--! @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.jsonb_blocked_contains_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.jsonb_blocked_contained_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); diff --git a/packages/stack/__tests__/helpers/eql-v3.ts b/packages/stack/__tests__/helpers/eql-v3.ts new file mode 100644 index 00000000..ee388161 --- /dev/null +++ b/packages/stack/__tests__/helpers/eql-v3.ts @@ -0,0 +1,53 @@ +import { readFile } from 'node:fs/promises' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' +import type postgres from 'postgres' + +const EQL_V3_ADVISORY_LOCK_ID = 3_733_003 + +const helperDir = dirname(fileURLToPath(import.meta.url)) +const eqlV3SqlPath = resolve( + helperDir, + '../fixtures/eql-v3/cipherstash-encrypt-v3.sql', +) + +async function hasEqlV3TextSearch(sql: postgres.Sql): Promise<boolean> { + const [row] = await sql<{ installed: boolean }[]>` + SELECT to_regtype('eql_v3.text_search') IS NOT NULL AS installed + ` + return row?.installed ?? false +} + +/** + * Install the generated EQL v3 SQL bundle only when the target database does + * not already expose eql_v3.text_search. + * + * The bundle starts with DROP SCHEMA IF EXISTS eql_v3 CASCADE, so callers must + * never run it unconditionally against a shared test database. + */ +export async function installEqlV3IfNeeded(sql: postgres.Sql): Promise<void> { + // Advisory locks are session-scoped, so the whole check/install/unlock flow + // must run on a single reserved connection. Issuing the lock/unlock via the + // pool can land them on different pooled backends — allowing an install race + // and unlocking a backend that never held the lock. + const reserved = await sql.reserve() + + try { + await reserved`SELECT pg_advisory_lock(${EQL_V3_ADVISORY_LOCK_ID})` + + try { + if (await hasEqlV3TextSearch(reserved)) return + + const eqlV3Sql = await readFile(eqlV3SqlPath, 'utf8') + await reserved.unsafe(eqlV3Sql) + + if (!(await hasEqlV3TextSearch(reserved))) { + throw new Error('EQL v3 installation did not create eql_v3.text_search') + } + } finally { + await reserved`SELECT pg_advisory_unlock(${EQL_V3_ADVISORY_LOCK_ID})` + } + } finally { + reserved.release() + } +} diff --git a/packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts b/packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts new file mode 100644 index 00000000..942e6211 --- /dev/null +++ b/packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts @@ -0,0 +1,15 @@ +/** + * Test stub for `@cipherstash/auth/wasm-inline`. + * + * See {@link file://./stub-protect-ffi-wasm-inline.ts} — the `/wasm-inline` + * subpath is not exported by the installed `@cipherstash/auth`, so this stub + * lets Vitest load `src/wasm-inline` for pure-helper unit tests. Aliased in via + * `vitest.config.ts`. + */ +export const AccessKeyStrategy = { + create: (): never => { + throw new Error( + '[test stub]: auth/wasm-inline AccessKeyStrategy.create not implemented', + ) + }, +} diff --git a/packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts b/packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts new file mode 100644 index 00000000..e26d34df --- /dev/null +++ b/packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts @@ -0,0 +1,29 @@ +/** + * Test stub for `@cipherstash/protect-ffi/wasm-inline`. + * + * The installed `@cipherstash/protect-ffi` only exports `.` — the `/wasm-inline` + * subpath does not exist, so Vitest cannot resolve `src/wasm-inline` (which + * imports it). These no-op stubs let the unit tests that only exercise pure + * helpers (`getColumnName`, `normalizeCastAs`) load the module. Aliased in via + * `vitest.config.ts`. Any test that actually needs WASM behaviour must mock it + * explicitly (see `wasm-inline-column-name.test.ts`). + */ +export const decrypt = (): never => { + throw new Error( + '[test stub]: protect-ffi/wasm-inline decrypt not implemented', + ) +} + +export const encrypt = (): never => { + throw new Error( + '[test stub]: protect-ffi/wasm-inline encrypt not implemented', + ) +} + +export const isEncrypted = (): boolean => false + +export const newClient = (): never => { + throw new Error( + '[test stub]: protect-ffi/wasm-inline newClient not implemented', + ) +} diff --git a/packages/stack/__tests__/model-column-mapping.test.ts b/packages/stack/__tests__/model-column-mapping.test.ts new file mode 100644 index 00000000..785a47cd --- /dev/null +++ b/packages/stack/__tests__/model-column-mapping.test.ts @@ -0,0 +1,43 @@ +import { describe, expect, it } from 'vitest' +import { resolveEncryptColumnMap } from '@/encryption/helpers/model-helpers' +import { encryptedColumn, encryptedTable as encryptedTableV2 } from '@/schema' +import { + encryptedDateColumn, + encryptedTable, + encryptedTextColumn, +} from '@/schema/v3' + +// `resolveEncryptColumnMap` is how the model path reconciles the two keyings a +// table can use: models are matched by JS property name, but the FFI / encrypt +// config is addressed by DB column name. A mismatch here is a real data-leak +// bug — a schema field that fails to match is passed through as plaintext. +describe('resolveEncryptColumnMap', () => { + it('v3: matches by JS property, addresses the FFI by DB name', () => { + const users = encryptedTable('users', { + createdOn: encryptedDateColumn('created_on'), + notes: encryptedTextColumn('notes'), // property == name + }) + + const { columnPaths, toColumnName } = resolveEncryptColumnMap(users) + + // Fields are matched against JS property names (what a model is keyed by)… + expect(columnPaths.sort()).toEqual(['createdOn', 'notes']) + // …and each maps to the DB name the config/FFI is keyed by. + expect(toColumnName('createdOn')).toBe('created_on') + expect(toColumnName('notes')).toBe('notes') + }) + + it('v2: no property→DB map, so both keying schemes are the JS property', () => { + // v2 `build()` keys columns by the JS property, so matching and addressing + // use that same key — the resolver must fall back to identity and leave the + // v2 model path unchanged. + const legacy = encryptedTableV2('legacy', { + fooBar: encryptedColumn('foo_bar'), + }) + + const { columnPaths, toColumnName } = resolveEncryptColumnMap(legacy) + + expect(columnPaths).toEqual(['fooBar']) + expect(toColumnName('fooBar')).toBe('fooBar') + }) +}) diff --git a/packages/stack/__tests__/schema-v3-client.test.ts b/packages/stack/__tests__/schema-v3-client.test.ts new file mode 100644 index 00000000..88cc7dd2 --- /dev/null +++ b/packages/stack/__tests__/schema-v3-client.test.ts @@ -0,0 +1,239 @@ +import 'dotenv/config' +import { beforeAll, describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { typedClient } from '@/encryption/v3' +import { Encryption } from '@/index' +import { + encryptedBoolColumn, + encryptedDateColumn, + encryptedInt4OrdColumn, + encryptedTable, + encryptedTextColumn, + encryptedTextEqColumn, + encryptedTextMatchColumn, + encryptedTextSearchColumn, + encryptedTimestamptzColumn, +} from '@/schema/v3' +import { unwrapResult } from './fixtures' + +const users = encryptedTable('schema_v3_client_users', { + email: encryptedTextSearchColumn('email'), + age: encryptedInt4OrdColumn('age'), + nickname: encryptedTextEqColumn('nickname'), + body: encryptedTextMatchColumn('body'), + notes: encryptedTextColumn('notes'), + active: encryptedBoolColumn('active'), + // camelCase JS property → snake_case DB name on purpose: the model path must + // match models by JS property (`createdOn`) yet address the FFI/config by DB + // name (`created_on`). The round-trip tests below exercise that mapping. + createdOn: encryptedDateColumn('created_on'), + occurredAt: encryptedTimestamptzColumn('occurred_at'), +}) + +const LIVE_CIPHERSTASH_ENABLED = Boolean( + process.env.CS_WORKSPACE_CRN && + process.env.CS_CLIENT_ID && + process.env.CS_CLIENT_KEY && + process.env.CS_CLIENT_ACCESS_KEY, +) + +const describeLive = LIVE_CIPHERSTASH_ENABLED ? describe : describe.skip + +describeLive('eql_v3 client integration', () => { + let protectClient: EncryptionClient + + beforeAll(async () => { + protectClient = await Encryption({ schemas: [users] }) + }) + + it('encrypts and decrypts a text_search column', async () => { + const encrypted = unwrapResult( + await protectClient.encrypt('ada@example.com', { + table: users, + column: users.email, + }), + ) + + expect(encrypted).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'email' }, + v: 2, + }) + expect(encrypted).toHaveProperty('c') + expect(encrypted).toHaveProperty('hm') + expect(encrypted).toHaveProperty('bf') + expect(encrypted).toHaveProperty('ob') + + const decrypted = unwrapResult(await protectClient.decrypt(encrypted)) + expect(decrypted).toBe('ada@example.com') + }, 30000) + + it('auto-infers equality query terms for text_search columns', async () => { + const queryTerm = unwrapResult( + await protectClient.encryptQuery('ada@example.com', { + table: users, + column: users.email, + }), + ) + + expect(queryTerm).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'email' }, + v: 2, + }) + expect(queryTerm).toHaveProperty('hm') + expect(queryTerm).not.toHaveProperty('c') + }, 30000) + + it('encrypts explicit freeTextSearch and orderAndRange query terms', async () => { + const matchTerm = unwrapResult( + await protectClient.encryptQuery('Ada Lovelace', { + table: users, + column: users.email, + queryType: 'freeTextSearch', + }), + ) + + const orderTerm = unwrapResult( + await protectClient.encryptQuery('ada@example.com', { + table: users, + column: users.email, + queryType: 'orderAndRange', + }), + ) + + expect(matchTerm).toHaveProperty('bf') + expect(matchTerm).not.toHaveProperty('c') + expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).not.toHaveProperty('c') + }, 30000) + + it('encrypts and decrypts storage-only v3 columns', async () => { + const encryptedText = unwrapResult( + await protectClient.encrypt('private note', { + table: users, + column: users.notes, + }), + ) + expect(encryptedText).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'notes' }, + v: 2, + }) + expect(encryptedText).toHaveProperty('c') + expect(encryptedText).not.toHaveProperty('hm') + expect(encryptedText).not.toHaveProperty('bf') + expect(encryptedText).not.toHaveProperty('ob') + expect(unwrapResult(await protectClient.decrypt(encryptedText))).toBe( + 'private note', + ) + + const encryptedBool = unwrapResult( + await protectClient.encrypt(true, { + table: users, + column: users.active, + }), + ) + expect(encryptedBool).toHaveProperty('c') + expect(unwrapResult(await protectClient.decrypt(encryptedBool))).toBe(true) + }, 30000) + + it('encrypts equality and order query terms for typed v3 columns', async () => { + const equalityTerm = unwrapResult( + await protectClient.encryptQuery('ada', { + table: users, + column: users.nickname, + }), + ) + expect(equalityTerm).toHaveProperty('hm') + expect(equalityTerm).not.toHaveProperty('c') + + const orderTerm = unwrapResult( + await protectClient.encryptQuery(37, { + table: users, + column: users.age, + queryType: 'orderAndRange', + }), + ) + expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).not.toHaveProperty('c') + }, 30000) + + it('encrypts free-text terms for text_match columns', async () => { + const encrypted = unwrapResult( + await protectClient.encrypt('Ada Lovelace wrote notes', { + table: users, + column: users.body, + }), + ) + expect(encrypted).toHaveProperty('c') + expect(encrypted).toHaveProperty('bf') + expect(encrypted).not.toHaveProperty('hm') + expect(encrypted).not.toHaveProperty('ob') + + const matchTerm = unwrapResult( + await protectClient.encryptQuery('Lovelace', { + table: users, + column: users.body, + queryType: 'freeTextSearch', + }), + ) + expect(matchTerm).toHaveProperty('bf') + expect(matchTerm).not.toHaveProperty('c') + }, 30000) + + // int8 (bigint) storage domains are omitted from the v3 SDK until the native + // protect-ffi supports lossless bigint round-tripping — a `bigint` fails JSON + // serialization and a `string` is rejected for a `big_int` column. Re-add a + // round-trip test alongside the domain builders when the FFI lands. + + // A `date` domain decrypts to an ISO 8601 string from the native FFI, so the + // single-value `decrypt` path returns a string (a lone ciphertext carries no + // column context). The typed client's `decryptModel` reconstructs a real + // `Date` from the encrypt-config `cast_as` (`reconstructRow`), keyed by the + // JS property (`createdOn`) even though the DB column is `created_on`. + it('round-trips a representative date storage domain via decryptModel', async () => { + const typed = typedClient(protectClient, users) + // Zero milliseconds so the FFI dropping sub-second precision (`...00Z` vs + // `...000Z`) does not perturb the reconstructed instant. + const day = new Date('2026-07-01T00:00:00.000Z') + + // Encrypt via the single-value path (the proven route for a `Date` domain), + // then decrypt through the model path so `reconstructRow` rebuilds a `Date` + // from the encrypt-config `cast_as`. + const dateEncrypted = unwrapResult( + await protectClient.encrypt(day, { + table: users, + column: users.createdOn, + }), + ) + // Guard against a false pass: the value must be an actual ciphertext, not a + // plaintext `Date` that would trivially satisfy the assertions below. + expect(dateEncrypted).toHaveProperty('c') + + const decrypted = unwrapResult( + await typed.decryptModel({ createdOn: dateEncrypted }, users), + ) + expect(decrypted.createdOn).toBeInstanceOf(Date) + expect(decrypted.createdOn).toEqual(day) + }, 30000) + + // Regression: a camelCase JS property mapping to a snake_case DB column + // (`nickname` is name==key, but `createdOn`→`created_on` is not) must be + // ENCRYPTED by the model path — not silently passed through as plaintext + // because the field key (`createdOn`) fails to match the DB-keyed config. + it('encrypts a property-vs-DB-name column through encryptModel (no plaintext leak)', async () => { + const typed = typedClient(protectClient, users) + const day = new Date('2026-07-01T00:00:00.000Z') + + const encrypted = unwrapResult( + await typed.encryptModel({ createdOn: day, notes: 'hello' }, users), + ) + // The schema field must become a ciphertext (has `c`), NOT remain a Date. + expect(encrypted.createdOn).not.toBeInstanceOf(Date) + expect(encrypted.createdOn).toHaveProperty('c') + expect(encrypted.notes).toHaveProperty('c') + + const decrypted = unwrapResult(await typed.decryptModel(encrypted, users)) + expect(decrypted.createdOn).toBeInstanceOf(Date) + expect(decrypted.createdOn).toEqual(day) + expect(decrypted.notes).toBe('hello') + }, 30000) +}) diff --git a/packages/stack/__tests__/schema-v3-pg.test.ts b/packages/stack/__tests__/schema-v3-pg.test.ts new file mode 100644 index 00000000..47c97056 --- /dev/null +++ b/packages/stack/__tests__/schema-v3-pg.test.ts @@ -0,0 +1,323 @@ +import 'dotenv/config' +import postgres from 'postgres' +import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { Encryption } from '@/index' +import { + encryptedBoolColumn, + encryptedInt4OrdColumn, + encryptedTable, + encryptedTextEqColumn, + encryptedTextSearchColumn, +} from '@/schema/v3' +import type { Encrypted } from '@/types' +import { unwrapResult } from './fixtures' +import { installEqlV3IfNeeded } from './helpers/eql-v3' + +const LIVE_EQL_V3_PG_ENABLED = Boolean( + process.env.DATABASE_URL && + process.env.CS_WORKSPACE_CRN && + process.env.CS_CLIENT_ID && + process.env.CS_CLIENT_KEY && + process.env.CS_CLIENT_ACCESS_KEY, +) + +const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip + +const databaseUrl = process.env.DATABASE_URL +const sql = LIVE_EQL_V3_PG_ENABLED + ? postgres(databaseUrl as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +const table = encryptedTable('protect_ci_v3_text_search', { + email: encryptedTextSearchColumn('email'), +}) + +const typedTable = encryptedTable('protect_ci_v3_typed_domains', { + age: encryptedInt4OrdColumn('age'), + nickname: encryptedTextEqColumn('nickname'), + active: encryptedBoolColumn('active'), +}) + +const TEST_RUN_ID = `test-run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` + +type InsertedRow = { + id: number + email: unknown + label: string +} + +type EncryptionPayload = postgres.JSONValue + +let protectClient: EncryptionClient + +async function encryptValue(value: string): Promise<EncryptionPayload> { + return unwrapResult( + await protectClient.encrypt(value, { + table, + column: table.email, + }), + ) as EncryptionPayload +} + +async function encryptQueryTerm( + value: string, + queryType?: 'equality' | 'freeTextSearch' | 'orderAndRange', +): Promise<EncryptionPayload> { + return unwrapResult( + await protectClient.encryptQuery(value, { + table, + column: table.email, + queryType, + }), + ) as EncryptionPayload +} + +async function insertRow(label: string, email: string): Promise<number> { + const encrypted = await encryptValue(email) + + const [inserted] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) + VALUES (${sql.json(encrypted)}::eql_v3.text_search, ${label}, ${TEST_RUN_ID}) + RETURNING id + ` + + return inserted.id +} + +async function decryptRow(row: InsertedRow): Promise<string> { + const decrypted = unwrapResult( + await protectClient.decrypt(row.email as Encrypted), + ) + expect(typeof decrypted).toBe('string') + return decrypted as string +} + +async function seedRows(): Promise<Record<string, number>> { + const rows = { + ada: await insertRow('ada', 'ada@example.com'), + grace: await insertRow('grace', 'grace@example.com'), + alan: await insertRow('alan', 'alan@example.net'), + zora: await insertRow('zora', 'zora@example.org'), + } + + return rows +} + +beforeAll(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await installEqlV3IfNeeded(sql) + protectClient = await Encryption({ schemas: [table, typedTable] }) + + await sql` + CREATE TABLE IF NOT EXISTS protect_ci_v3_text_search ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + email eql_v3.text_search NOT NULL, + label TEXT NOT NULL, + test_run_id TEXT NOT NULL + ) + ` + + await sql` + CREATE TABLE IF NOT EXISTS protect_ci_v3_typed_domains ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + age eql_v3.int4_ord NOT NULL, + nickname eql_v3.text_eq NOT NULL, + active eql_v3.bool NOT NULL, + test_run_id TEXT NOT NULL + ) + ` +}, 30000) + +beforeEach(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await sql` + DELETE FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + ` + await sql` + DELETE FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + ` +}, 30000) + +afterAll(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await sql` + DELETE FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + ` + await sql` + DELETE FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + ` + await sql.end() +}, 30000) + +describeLivePg('eql_v3 text_search postgres integration', () => { + it('round-trips an encrypted value through an eql_v3.text_search column', async () => { + const id = await insertRow('roundtrip', 'roundtrip@example.com') + + const [row] = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE id = ${id} + ` + + expect(row).toBeDefined() + await expect(decryptRow(row)).resolves.toBe('roundtrip@example.com') + }, 30000) + + it('queries equality terms with eql_v3.eq_term and eql_v3.hmac_256', async () => { + const ids = await seedRows() + const equalityTerm = await encryptQueryTerm('grace@example.com', 'equality') + + const rows = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.eq_term(email) = eql_v3.hmac_256(${sql.json(equalityTerm)}::jsonb) + ORDER BY id + ` + + expect(rows.map((row) => row.id)).toEqual([ids.grace]) + await expect(decryptRow(rows[0])).resolves.toBe('grace@example.com') + }, 30000) + + it('queries free-text terms with eql_v3.match_term and eql_v3.bloom_filter', async () => { + await seedRows() + const matchTerm = await encryptQueryTerm('example.com', 'freeTextSearch') + + const rows = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.match_term(email) @> eql_v3.bloom_filter(${sql.json(matchTerm)}::jsonb) + ORDER BY label + ` + + expect(rows.map((row) => row.label)).toEqual(['ada', 'grace']) + }, 30000) + + it('queries range terms with eql_v3.ord_term and eql_v3.ore_block_256', async () => { + await seedRows() + const lower = await encryptQueryTerm('grace@example.com', 'orderAndRange') + const upper = await encryptQueryTerm('zora@example.org', 'orderAndRange') + + const rows = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(email) >= eql_v3.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) + ` + + expect(rows.map((row) => row.label)).toEqual(['grace', 'zora']) + }, 30000) + + it('creates functional indexes for equality, match, and order terms', async () => { + await sql` + CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_eq_idx + ON protect_ci_v3_text_search USING btree (eql_v3.eq_term(email)) + ` + await sql` + CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_match_idx + ON protect_ci_v3_text_search USING gin (eql_v3.match_term(email)) + ` + await sql` + CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_ord_idx + ON protect_ci_v3_text_search USING btree (eql_v3.ord_term(email)) + ` + + const indexes = await sql<{ indexname: string; indexdef: string }[]>` + SELECT indexname, indexdef + FROM pg_indexes + WHERE schemaname = 'public' + AND tablename = 'protect_ci_v3_text_search' + AND indexname IN ( + 'protect_ci_v3_text_search_email_eq_idx', + 'protect_ci_v3_text_search_email_match_idx', + 'protect_ci_v3_text_search_email_ord_idx' + ) + ` + + expect(indexes).toHaveLength(3) + expect(indexes.map((idx) => idx.indexdef).join('\n')).toContain( + 'eql_v3.eq_term', + ) + expect(indexes.map((idx) => idx.indexdef).join('\n')).toContain( + 'eql_v3.match_term', + ) + expect(indexes.map((idx) => idx.indexdef).join('\n')).toContain( + 'eql_v3.ord_term', + ) + }, 30000) + + it('rejects query-only payloads cast as eql_v3.text_search values', async () => { + const equalityTerm = await encryptQueryTerm('ada@example.com', 'equality') + + await expect( + sql` + INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) + VALUES ( + ${sql.json(equalityTerm)}::eql_v3.text_search, + 'query-only', + ${TEST_RUN_ID} + ) + `, + ).rejects.toThrow() + }, 30000) + + it('round-trips and queries representative typed v3 domains', async () => { + const age = unwrapResult( + await protectClient.encrypt(37, { + table: typedTable, + column: typedTable.age, + }), + ) + const nickname = unwrapResult( + await protectClient.encrypt('ada', { + table: typedTable, + column: typedTable.nickname, + }), + ) + const active = unwrapResult( + await protectClient.encrypt(true, { + table: typedTable, + column: typedTable.active, + }), + ) + + const [inserted] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) + VALUES ( + ${sql.json(age as postgres.JSONValue)}::eql_v3.int4_ord, + ${sql.json(nickname as postgres.JSONValue)}::eql_v3.text_eq, + ${sql.json(active as postgres.JSONValue)}::eql_v3.bool, + ${TEST_RUN_ID} + ) + RETURNING id + ` + + const ageTerm = unwrapResult( + await protectClient.encryptQuery(30, { + table: typedTable, + column: typedTable.age, + queryType: 'orderAndRange', + }), + ) as postgres.JSONValue + + const rows = await sql<{ id: number }[]>` + SELECT id + FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(age) >= eql_v3.ore_block_256(${sql.json(ageTerm)}::jsonb) + ` + + expect(rows.map((row) => row.id)).toContain(inserted.id) + }, 30000) +}) diff --git a/packages/stack/__tests__/schema-v3.test-d.ts b/packages/stack/__tests__/schema-v3.test-d.ts new file mode 100644 index 00000000..b99fdbe3 --- /dev/null +++ b/packages/stack/__tests__/schema-v3.test-d.ts @@ -0,0 +1,360 @@ +import { describe, expectTypeOf, it } from 'vitest' +import { Encryption, type EncryptionClient } from '@/encryption' +// v2 column builders — used to prove the v3 table type rejects a v2 column and +// to assert v2 backward-compat against the widened client types. +import { + encryptedColumn, + encryptedField, + encryptedTable as v2EncryptedTable, +} from '@/schema' +import type { + EncryptedTextSearchColumn, + InferEncrypted, + InferPlaintext, +} from '@/schema/v3' +import { + encryptedBoolColumn, + encryptedDateColumn, + encryptedFloat8Column, + encryptedInt4Column, + encryptedTable, + encryptedTextColumn, + encryptedTextEqColumn, + encryptedTextMatchColumn, + encryptedTextSearchColumn, + encryptedTimestamptzColumn, + encryptedTimestamptzOrdColumn, +} from '@/schema/v3' +import type { Encrypted } from '@/types' + +describe('eql_v3 schema type inference', () => { + it('encryptedTextSearchColumn returns an EncryptedTextSearchColumn', () => { + const col = encryptedTextSearchColumn('email') + expectTypeOf(col).toEqualTypeOf<EncryptedTextSearchColumn>() + }) + + it('encryptedTable exposes column builders as typed properties', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + expectTypeOf(users.email).toEqualTypeOf<EncryptedTextSearchColumn>() + expectTypeOf(users.tableName).toBeString() + }) + + it('rejects a v2 EncryptedColumn in a v3 table (nominal private-field mismatch)', () => { + encryptedTable('users', { + // @ts-expect-error - a v2 EncryptedColumn is not an EncryptedTextSearchColumn + email: encryptedColumn('email'), + }) + }) + + it('InferPlaintext maps each column to string', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + name: encryptedTextSearchColumn('name'), + }) + type Plaintext = InferPlaintext<typeof users> + expectTypeOf<Plaintext>().toEqualTypeOf<{ email: string; name: string }>() + }) + + it('InferEncrypted maps each column to Encrypted', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + type Enc = InferEncrypted<typeof users> + expectTypeOf<Enc>().toEqualTypeOf<{ email: Encrypted }>() + }) + + it('InferPlaintext maps v3 concrete domains to plaintext TypeScript types', () => { + const metrics = encryptedTable('metrics', { + name: encryptedTextColumn('name'), + age: encryptedInt4Column('age'), + active: encryptedBoolColumn('active'), + createdAt: encryptedTimestamptzColumn('created_at'), + score: encryptedFloat8Column('score'), + }) + + type Plaintext = InferPlaintext<typeof metrics> + + expectTypeOf<Plaintext>().toEqualTypeOf<{ + name: string + age: number + active: boolean + createdAt: Date + score: number + }>() + }) + + it('v3 domain classes remain nominal by literal domain definition', () => { + const date = encryptedDateColumn('created_on') + const bool = encryptedBoolColumn('active') + + expectTypeOf(date).not.toEqualTypeOf<typeof bool>() + + // @ts-expect-error - storage-only bool is not assignable to storage-only date + const invalid: typeof date = bool + void invalid + }) +}) + +describe('eql_v3 client integration (type-level acceptance)', () => { + const v3users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + + it('Encryption accepts a v3 schema', () => { + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v3users] }) + }) + + it('encrypt accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('encryptQuery accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('decrypt accepts an Encrypted value (round-trip target type; schema-independent)', () => { + const client = {} as EncryptionClient + expectTypeOf(client.decrypt).toBeCallableWith({} as Encrypted) + }) + + it('BACKWARD COMPAT: v2 tables/columns still satisfy the widened types', () => { + const v2users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v2users] }) + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + // a v2 EncryptedColumn is STILL queryable (nominal arm of BuildableQueryColumn) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + }) + + it('a non-queryable v2 EncryptedField is encryptable but NOT queryable', () => { + const v2usersWithField = v2EncryptedTable('users', { + profile: { email: encryptedField('email') }, + }) + const client = {} as EncryptionClient + + // POSITIVE: a field IS encryptable (storage path = BuildableColumn) + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2usersWithField, + column: v2usersWithField.profile.email, + }) + + // NEGATIVE: a field is NOT queryable. The query path uses + // BuildableQueryColumn, which excludes EncryptedField (no indexes). If the + // query path were instead widened to BuildableColumn (the rejected + // Batch-2/3 design), this call would compile and only fail at runtime with + // "no indexes configured" — so this test guards against that re-widening. + // + // The mismatch is a DEEP object-literal property error, so tsc reports it on + // the `column:` line — the `@ts-expect-error` MUST sit directly above that + // line (not above the call), or you get TS2578 "unused directive" + the real + // error leaking. (Mirror of Task 4's v2-column-rejected test placement.) + client.encryptQuery('alice@example.com', { + table: v2usersWithField, + // @ts-expect-error - EncryptedField is not assignable to BuildableQueryColumn + column: v2usersWithField.profile.email, + }) + }) + + it('encryptQuery accepts queryable v3 columns with explicit capability metadata', () => { + const users = encryptedTable('users', { + emailEq: encryptedTextEqColumn('email_eq'), + emailMatch: encryptedTextMatchColumn('email_match'), + emailSearch: encryptedTextSearchColumn('email_search'), + createdAt: encryptedTimestamptzOrdColumn('created_at'), + }) + const client = {} as EncryptionClient + + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailEq, + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('ali', { + table: users, + column: users.emailMatch, + queryType: 'freeTextSearch', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + queryType: 'orderAndRange', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailSearch, + queryType: 'equality', + }) + }) + + it('encryptQuery rejects storage-only v3 columns at compile time', () => { + const users = encryptedTable('users', { + email: encryptedTextColumn('email'), + active: encryptedBoolColumn('active'), + }) + const client = {} as EncryptionClient + + client.encryptQuery('alice@example.com', { + table: users, + // @ts-expect-error - storage-only v3 text column is not queryable + column: users.email, + }) + + client.encryptQuery(true, { + table: users, + // @ts-expect-error - storage-only v3 bool column is not queryable + column: users.active, + }) + }) +}) + +describe('eql_v3 model encryption inference', () => { + it('encryptModel and bulkEncryptModels infer encrypted fields from v3 tables', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + active: encryptedBoolColumn('active'), + }) + const client = {} as EncryptionClient + + const encryptedOne = client.encryptModel( + { id: 'u1', email: 'alice@example.com', active: true, untouched: 42 }, + users, + ) + expectTypeOf(encryptedOne).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + active: Encrypted + untouched: number + }> + >() + + const encryptedMany = client.bulkEncryptModels( + [{ id: 'u1', email: 'alice@example.com', active: true }], + users, + ) + expectTypeOf(encryptedMany).toEqualTypeOf< + import('@/encryption').BulkEncryptModelsOperation<{ + id: string + email: Encrypted + active: Encrypted + }> + >() + }) + + it('v3 encryptModel preserves unrelated and nullable fields', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: null as string | null, untouched: 42 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted | null + untouched: number + }> + >() + }) + + it('encryptModel degrades gracefully for a bare BuildableTable-typed value (no brand)', () => { + // A table passed through a value/param annotated as the structural + // `BuildableTable` (no `_columnType` brand) cannot recover its literal + // column keys. It must degrade to the model unchanged — NOT mark every + // field `Encrypted`. Regression guard: `keyof BuildableTableColumns<...>` + // must resolve to `never` here, not `keyof never` (= string|number|symbol), + // which would wrongly encrypt all fields including `id` and `untouched`. + const usersConcrete = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const table: import('@/types').BuildableTable = usersConcrete + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: 'alice@example.com', untouched: 42 }, + table, + ) + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: string + untouched: number + }> + >() + }) + + it('model inference keys off the property name, not the DB column name (aliased columns)', () => { + // The column's DB name ('created_at') differs from the object property name + // ('occurredAt'). Model inference keys off the PROPERTY name, so `occurredAt` + // must become `Encrypted` while unrelated fields are preserved verbatim. + const events = encryptedTable('events', { + occurredAt: encryptedTimestamptzColumn('created_at'), + }) + const client = {} as EncryptionClient + + const encryptedOne = client.encryptModel( + { id: 'e1', occurredAt: new Date(), label: 'signup' }, + events, + ) + expectTypeOf(encryptedOne).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + occurredAt: Encrypted + label: string + }> + >() + + const encryptedMany = client.bulkEncryptModels( + [{ id: 'e1', occurredAt: new Date(), label: 'signup' }], + events, + ) + expectTypeOf(encryptedMany).toEqualTypeOf< + import('@/encryption').BulkEncryptModelsOperation<{ + id: string + occurredAt: Encrypted + label: string + }> + >() + }) + + it('v2 encryptModel inference still preserves non-schema fields after widening', () => { + const users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: 'alice@example.com', age: 30 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + age: number + }> + >() + }) +}) diff --git a/packages/stack/__tests__/schema-v3.test.ts b/packages/stack/__tests__/schema-v3.test.ts new file mode 100644 index 00000000..a9a4ae77 --- /dev/null +++ b/packages/stack/__tests__/schema-v3.test.ts @@ -0,0 +1,695 @@ +import { describe, expect, it } from 'vitest' +import { resolveIndexType } from '@/encryption/helpers/infer-index-type' +import { encryptConfigSchema, encryptedColumn } from '@/schema' +import { + buildEncryptConfig, + EncryptedBoolColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedFloat4Column, + EncryptedFloat4EqColumn, + EncryptedFloat4OrdColumn, + EncryptedFloat4OrdOreColumn, + EncryptedFloat8Column, + EncryptedFloat8EqColumn, + EncryptedFloat8OrdColumn, + EncryptedFloat8OrdOreColumn, + EncryptedInt2Column, + EncryptedInt2EqColumn, + EncryptedInt2OrdColumn, + EncryptedInt2OrdOreColumn, + EncryptedInt4Column, + EncryptedInt4EqColumn, + EncryptedInt4OrdColumn, + EncryptedInt4OrdOreColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedTable, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestamptzColumn, + EncryptedTimestamptzEqColumn, + EncryptedTimestamptzOrdColumn, + EncryptedTimestamptzOrdOreColumn, + encryptedBoolColumn, + encryptedDateColumn, + encryptedDateEqColumn, + encryptedDateOrdColumn, + encryptedDateOrdOreColumn, + encryptedFloat4Column, + encryptedFloat4EqColumn, + encryptedFloat4OrdColumn, + encryptedFloat4OrdOreColumn, + encryptedFloat8Column, + encryptedFloat8EqColumn, + encryptedFloat8OrdColumn, + encryptedFloat8OrdOreColumn, + encryptedInt2Column, + encryptedInt2EqColumn, + encryptedInt2OrdColumn, + encryptedInt2OrdOreColumn, + encryptedInt4Column, + encryptedInt4EqColumn, + encryptedInt4OrdColumn, + encryptedInt4OrdOreColumn, + encryptedNumericColumn, + encryptedNumericEqColumn, + encryptedNumericOrdColumn, + encryptedNumericOrdOreColumn, + encryptedTable, + encryptedTextColumn, + encryptedTextEqColumn, + encryptedTextMatchColumn, + encryptedTextOrdColumn, + encryptedTextOrdOreColumn, + encryptedTextSearchColumn, + encryptedTimestamptzColumn, + encryptedTimestamptzEqColumn, + encryptedTimestamptzOrdColumn, + encryptedTimestamptzOrdOreColumn, +} from '@/schema/v3' + +const domainCases = [ + [ + 'eql_v3.int4', + encryptedInt4Column, + EncryptedInt4Column, + 'number', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.int4_eq', + encryptedInt4EqColumn, + EncryptedInt4EqColumn, + 'number', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.int4_ord_ore', + encryptedInt4OrdOreColumn, + EncryptedInt4OrdOreColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.int4_ord', + encryptedInt4OrdColumn, + EncryptedInt4OrdColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.int2', + encryptedInt2Column, + EncryptedInt2Column, + 'number', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.int2_eq', + encryptedInt2EqColumn, + EncryptedInt2EqColumn, + 'number', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.int2_ord_ore', + encryptedInt2OrdOreColumn, + EncryptedInt2OrdOreColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.int2_ord', + encryptedInt2OrdColumn, + EncryptedInt2OrdColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.date', + encryptedDateColumn, + EncryptedDateColumn, + 'date', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.date_eq', + encryptedDateEqColumn, + EncryptedDateEqColumn, + 'date', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.date_ord_ore', + encryptedDateOrdOreColumn, + EncryptedDateOrdOreColumn, + 'date', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.date_ord', + encryptedDateOrdColumn, + EncryptedDateOrdColumn, + 'date', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.timestamptz', + encryptedTimestamptzColumn, + EncryptedTimestamptzColumn, + 'date', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.timestamptz_eq', + encryptedTimestamptzEqColumn, + EncryptedTimestamptzEqColumn, + 'date', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.timestamptz_ord_ore', + encryptedTimestamptzOrdOreColumn, + EncryptedTimestamptzOrdOreColumn, + 'date', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.timestamptz_ord', + encryptedTimestamptzOrdColumn, + EncryptedTimestamptzOrdColumn, + 'date', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.numeric', + encryptedNumericColumn, + EncryptedNumericColumn, + 'number', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.numeric_eq', + encryptedNumericEqColumn, + EncryptedNumericEqColumn, + 'number', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.numeric_ord_ore', + encryptedNumericOrdOreColumn, + EncryptedNumericOrdOreColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.numeric_ord', + encryptedNumericOrdColumn, + EncryptedNumericOrdColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.text', + encryptedTextColumn, + EncryptedTextColumn, + 'string', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.text_eq', + encryptedTextEqColumn, + EncryptedTextEqColumn, + 'string', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.text_match', + encryptedTextMatchColumn, + EncryptedTextMatchColumn, + 'string', + { + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + { equality: false, orderAndRange: false, freeTextSearch: true }, + ], + [ + 'eql_v3.text_ord_ore', + encryptedTextOrdOreColumn, + EncryptedTextOrdOreColumn, + 'string', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.text_ord', + encryptedTextOrdColumn, + EncryptedTextOrdColumn, + 'string', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.bool', + encryptedBoolColumn, + EncryptedBoolColumn, + 'boolean', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.float4', + encryptedFloat4Column, + EncryptedFloat4Column, + 'number', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.float4_eq', + encryptedFloat4EqColumn, + EncryptedFloat4EqColumn, + 'number', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.float4_ord_ore', + encryptedFloat4OrdOreColumn, + EncryptedFloat4OrdOreColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.float4_ord', + encryptedFloat4OrdColumn, + EncryptedFloat4OrdColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.float8', + encryptedFloat8Column, + EncryptedFloat8Column, + 'number', + {}, + { equality: false, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.float8_eq', + encryptedFloat8EqColumn, + EncryptedFloat8EqColumn, + 'number', + { unique: { token_filters: [] } }, + { equality: true, orderAndRange: false, freeTextSearch: false }, + ], + [ + 'eql_v3.float8_ord_ore', + encryptedFloat8OrdOreColumn, + EncryptedFloat8OrdOreColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], + [ + 'eql_v3.float8_ord', + encryptedFloat8OrdColumn, + EncryptedFloat8OrdColumn, + 'number', + { ore: {} }, + { equality: true, orderAndRange: true, freeTextSearch: false }, + ], +] as const + +describe('eql_v3 concrete domain columns', () => { + it.each( + domainCases, + )('%s builder exposes name, config, type, and capabilities', (eqlType, factory, Klass, castAs, indexes, capabilities) => { + const col = factory('value') + expect(col).toBeInstanceOf(Klass) + expect(col.getName()).toBe('value') + expect(col.getEqlType()).toBe(eqlType) + expect(col.getQueryCapabilities()).toStrictEqual(capabilities) + expect(col.isQueryable()).toBe(Object.values(capabilities).some(Boolean)) + expect(col.build()).toStrictEqual({ cast_as: castAs, indexes }) + expect(col.build()).not.toHaveProperty('eqlType') + expect(col.build()).not.toHaveProperty('queryCapabilities') + }) +}) + +describe('eql_v3 text_search column', () => { + it('returns an EncryptedTextSearchColumn with the correct name', () => { + const col = encryptedTextSearchColumn('email') + expect(col).toBeInstanceOf(EncryptedTextSearchColumn) + expect(col.getName()).toBe('email') + }) + + it('.build() emits the pinned default config (cast_as: string + all three indexes)', () => { + const built = encryptedTextSearchColumn('email').build() + // toStrictEqual (not toEqual) so a stray `undefined` key would fail. + expect(built).toStrictEqual({ + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }) + }) + + it('LOAD-BEARING: default build() deep-equals the v2 equality+order+match column', () => { + const v3 = encryptedTextSearchColumn('email').build() + const v2 = encryptedColumn('email') + .equality() + .orderAndRange() + .freeTextSearch() + .build() + // toStrictEqual: byte-identical, no extra/undefined keys on either side. + expect(v3).toStrictEqual(v2) + }) + + it('.freeTextSearch(opts) overrides each provided key and keeps the rest as defaults', () => { + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + k: 8, + m: 4096, + include_original: false, + }) + .build() + expect(built.indexes.match).toEqual({ + tokenizer: { kind: 'ngram', token_length: 4 }, + // omitted -> default downcase filter retained + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }) + }) + + it('.freeTextSearch({ token_filters: [] }) overrides the downcase default with an empty array', () => { + // LOAD-BEARING: `[] ?? default` evaluates to `[]` (an empty array is not + // nullish), so an explicit empty array must OVERRIDE the downcase default, + // not fall back to it. Mirrors v2 (schema-builders.test.ts). + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ token_filters: [] }) + .build() + expect(built.indexes.match.token_filters).toEqual([]) + }) + + it('repeated .freeTextSearch() calls are last-call-wins-fully (each re-merges against defaults, not prior state)', () => { + // Each call re-merges against a fresh defaultMatchOpts(), not the + // accumulated matchOpts — so the second call resets k back to its default + // of 6. This is intentional: it mirrors v2 exactly. Pinned here so a future + // "merge against current state" change can't silently slip in. + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ k: 8 }) + .freeTextSearch({ m: 4096 }) + .build() + expect(built.indexes.match.k).toBe(6) + expect(built.indexes.match.m).toBe(4096) + }) + + it('.freeTextSearch() is tuning-only: unique and ore indexes stay present', () => { + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ k: 8 }) + .build() + expect(built.indexes.unique).toEqual({ token_filters: [] }) + expect(built.indexes.ore).toEqual({}) + }) + + it('getEqlType() returns the concrete domain name', () => { + const col = encryptedTextSearchColumn('email') + expect(col.getEqlType()).toBe('eql_v3.text_search') + }) + + it('exposes full query capabilities and is queryable', () => { + expect( + encryptedTextSearchColumn('email').getQueryCapabilities(), + ).toStrictEqual({ + equality: true, + orderAndRange: true, + freeTextSearch: true, + }) + expect(encryptedTextSearchColumn('email').isQueryable()).toBe(true) + }) + + it('eqlType metadata is absent from build() output', () => { + const built = encryptedTextSearchColumn('email').build() + expect(built).not.toHaveProperty('eqlType') + expect(Object.keys(built).sort()).toEqual(['cast_as', 'indexes']) + }) + + it('built columns share no mutable state: mutating one build() output does not affect another', () => { + // Guards against the shared-defaults aliasing bug: defaults come from a + // per-instance factory and build() deep-clones the match block. + const a = encryptedTextSearchColumn('a').build() + const b = encryptedTextSearchColumn('b').build() + + // Mutate every nested level of a's match block. + a.indexes.match.k = 999 + a.indexes.match.token_filters.push({ kind: 'downcase' }) + a.indexes.match.tokenizer = { kind: 'standard' } + + expect(b.indexes.match.k).toBe(6) + expect(b.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + expect(b.indexes.match.tokenizer).toEqual({ + kind: 'ngram', + token_length: 3, + }) + + // A second build() of an independent column is also pristine. + const c = encryptedTextSearchColumn('c').build() + expect(c.indexes.match.k).toBe(6) + expect(c.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) + + it('clones caller opts on freeTextSearch(): mutating them before build() does not leak', () => { + // build() deep-clones at build time, but if freeTextSearch stored the + // caller's nested tokenizer / token_filters by reference, a caller mutating + // their own opts object between freeTextSearch(opts) and build() would leak + // the mutation into the emitted config. freeTextSearch must clone on write. + const opts = { + tokenizer: { kind: 'ngram' as const, token_length: 3 }, + token_filters: [{ kind: 'downcase' as const }], + } + const col = encryptedTextSearchColumn('email').freeTextSearch(opts) + + // Mutate the caller's own opts AFTER freeTextSearch but BEFORE build(). + opts.tokenizer.token_length = 999 + opts.token_filters.push({ kind: 'downcase' as const }) + + const built = col.build() + expect(built.indexes.match.tokenizer).toEqual({ + kind: 'ngram', + token_length: 3, + }) + expect(built.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) +}) + +describe('eql_v3 encryptedTable', () => { + it('creates a table exposing column builders as properties', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + expect(users).toBeInstanceOf(EncryptedTable) + expect(users.tableName).toBe('users') + expect(users.email).toBeInstanceOf(EncryptedTextSearchColumn) + }) + + it('table.email returns the same builder instance passed in', () => { + const emailCol = encryptedTextSearchColumn('email') + const users = encryptedTable('users', { email: emailCol }) + expect(users.email).toBe(emailCol) + }) + + it.each([ + 'build', + 'tableName', + 'columnBuilders', + '_columnType', + // Inherited Object.prototype members: assigning these as own properties + // would shadow the prototype method/accessor. Guard them too so the + // table object stays well-behaved for reflection / serialization. + 'constructor', + 'toString', + 'valueOf', + 'hasOwnProperty', + ])('throws when a column name (%s) collides with a reserved property', (reserved) => { + expect(() => + encryptedTable('users', { + [reserved]: encryptedTextSearchColumn(reserved), + }), + ).toThrow(/reserved EncryptedTable property/) + }) + + it('build() assembles { tableName, columns } with built column configs', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const built = users.build() + expect(built.tableName).toBe('users') + expect(built.columns).toStrictEqual({ + email: { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }, + }) + }) +}) + +describe('eql_v3 buildEncryptConfig', () => { + it('produces a { v: 1, tables } config', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const config = buildEncryptConfig(users) + expect(config.v).toBe(1) + expect(config.tables).toHaveProperty('users') + expect(config.tables.users).toHaveProperty('email') + }) + + it('emits a config that passes encryptConfigSchema.parse()', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const config = buildEncryptConfig(users) + expect(() => encryptConfigSchema.parse(config)).not.toThrow() + }) + + it('supports multiple tables', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const posts = encryptedTable('posts', { + body: encryptedTextSearchColumn('body'), + }) + const config = buildEncryptConfig(users, posts) + expect(Object.keys(config.tables).sort()).toEqual(['posts', 'users']) + }) + + it('keys columns by DB name (getName), not the JS property name', () => { + // A camelCase JS key mapping to a snake_case DB column must register the + // config under the DB name — `encrypt`/`decrypt` look columns up by + // `column.getName()`, so keying by the JS property name makes the FFI + // report "column not found in Encrypt config" at encrypt time. + const users = encryptedTable('accounts', { + createdOn: encryptedDateColumn('created_on'), + lastSeen: encryptedTimestamptzColumn('last_seen'), + }) + const config = buildEncryptConfig(users) + expect(Object.keys(config.tables.accounts).sort()).toEqual([ + 'created_on', + 'last_seen', + ]) + expect(config.tables.accounts).not.toHaveProperty('createdOn') + expect(config.tables.accounts).not.toHaveProperty('lastSeen') + }) + + it('buildColumnKeyMap maps JS property → DB column name', () => { + // The model path matches user models by JS property but must address the + // FFI/config by DB name. `build()` discards the property→name relationship + // (it keys by DB name); `buildColumnKeyMap()` recovers it. + const users = encryptedTable('accounts', { + createdOn: encryptedDateColumn('created_on'), + lastSeen: encryptedTimestamptzColumn('last_seen'), + email: encryptedTextSearchColumn('email'), + }) + expect(users.buildColumnKeyMap()).toEqual({ + createdOn: 'created_on', + lastSeen: 'last_seen', + email: 'email', + }) + }) + + it('throws when two tables share the same tableName (no silent drop)', () => { + // v3-only additive guard: keying config.tables by name means a duplicate + // would silently overwrite the earlier table. Fail loudly instead so the + // footgun surfaces at build time. (v2 keeps its silent-overwrite behavior + // unchanged — the no-v2-change constraint.) + const a = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const b = encryptedTable('users', { + name: encryptedTextSearchColumn('name'), + }) + expect(() => buildEncryptConfig(a, b)).toThrow( + /duplicate table name "users"/, + ) + }) +}) + +describe('eql_v3 query capability misuse', () => { + it('throws when querying a storage-only v3 column at runtime', () => { + const raw = encryptedTextColumn('raw') + expect(() => resolveIndexType(raw as never)).toThrow( + /no indexes configured/, + ) + }) + + it('throws when a query type is not configured on a queryable v3 column', () => { + const matchOnly = encryptedTextMatchColumn('body') + expect(() => resolveIndexType(matchOnly, 'equality')).toThrow( + /Index type "unique" is not configured/, + ) + expect(() => resolveIndexType(matchOnly, 'orderAndRange')).toThrow( + /Index type "ore" is not configured/, + ) + }) +}) diff --git a/packages/stack/__tests__/typed-client-v3.test-d.ts b/packages/stack/__tests__/typed-client-v3.test-d.ts new file mode 100644 index 00000000..54bfca0c --- /dev/null +++ b/packages/stack/__tests__/typed-client-v3.test-d.ts @@ -0,0 +1,177 @@ +import { describe, expectTypeOf, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +// Everything comes from the single `@cipherstash/stack/v3` surface (re-exported +// from src/encryption/v3.ts), exercising the re-export at the same time. +import { + encryptedInt4OrdColumn, + encryptedTable, + encryptedTextColumn, + encryptedTextEqColumn, + encryptedTextSearchColumn, + encryptedTimestamptzOrdColumn, + typedClient, + type V3DecryptedModel, + type V3EncryptedModel, +} from '@/encryption/v3' +import type { Encrypted } from '@/types' + +// A v3 table mixing every relevant capability tier: +const users = encryptedTable('users', { + email: encryptedTextEqColumn('email'), // equality only + bio: encryptedTextSearchColumn('bio'), // equality + order + free-text + note: encryptedTextColumn('note'), // storage only (not queryable) + createdAt: encryptedTimestamptzOrdColumn('created_at'), // equality + order +}) + +// A second registered table whose `weight` domain (int4_ord) is NOT present in +// `users`, so borrowing it is a genuine cross-table type error. +const other = encryptedTable('other', { + weight: encryptedInt4OrdColumn('weight'), +}) + +const client = typedClient({} as EncryptionClient, users, other) + +describe('typed v3 client — encrypt plaintext is pinned to the column domain', () => { + it('accepts the matching plaintext type per domain', () => { + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: users, + column: users.email, + }) + expectTypeOf(client.encrypt).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + }) + }) + + it('rejects a wrong-typed plaintext', () => { + client.encrypt( + // @ts-expect-error - number is not valid plaintext for a text column + 123, + { table: users, column: users.email }, + ) + }) +}) + +describe('typed v3 client — encryptQuery constrains queryType to capabilities', () => { + it('accepts capability-matched query types', () => { + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.email, + queryType: 'equality', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + queryType: 'orderAndRange', + }) + // text_search supports all three + expectTypeOf(client.encryptQuery).toBeCallableWith('needle', { + table: users, + column: users.bio, + queryType: 'freeTextSearch', + }) + }) + + it('rejects a query type the column does not support', () => { + client.encryptQuery('alice@example.com', { + table: users, + column: users.email, // equality only + // @ts-expect-error - text_eq column does not support 'orderAndRange' + queryType: 'orderAndRange', + }) + client.encryptQuery(new Date(), { + table: users, + column: users.createdAt, // equality + order, no free-text + // @ts-expect-error - timestamptz_ord column does not support 'freeTextSearch' + queryType: 'freeTextSearch', + }) + }) + + it('rejects a storage-only column on the query path', () => { + client.encryptQuery('x', { + table: users, + // @ts-expect-error - storage-only text column is not queryable + column: users.note, + }) + }) +}) + +describe('typed v3 client — model encrypt validates schema fields', () => { + it('accepts a model whose schema fields match and allows passthrough fields', () => { + expectTypeOf(client.encryptModel).toBeCallableWith( + { id: 'u1', email: 'a@b.com', createdAt: new Date() }, + users, + ) + }) + + it('rejects a wrong-typed schema field', () => { + client.encryptModel( + { + id: 'u1', + // @ts-expect-error - email expects string, got number + email: 123, + }, + users, + ) + }) + + it('maps schema columns to Encrypted and preserves passthrough + nullability', () => { + // Passthrough `id` stays string; schema `email` becomes Encrypted. + expectTypeOf< + V3EncryptedModel<typeof users, { id: string; email: string }> + >().toEqualTypeOf<{ id: string; email: Encrypted }>() + + // Nullable schema field → Encrypted | null. + expectTypeOf< + V3EncryptedModel<typeof users, { id: string; email: string | null }> + >().toEqualTypeOf<{ id: string; email: Encrypted | null }>() + }) +}) + +describe('typed v3 client — model decrypt yields precise plaintext', () => { + it('reconstructs schema columns to their plaintext type regardless of the input field type', () => { + // Input is the encrypted row; output pins each schema column to its plaintext + // type (Date for timestamptz, string for text). + expectTypeOf< + V3DecryptedModel< + typeof users, + { id: string; email: Encrypted; createdAt: Encrypted } + > + >().toEqualTypeOf<{ + id: string + email: string + createdAt: Date + }>() + }) + + it('decryptModel is callable with an encrypted row and the table', () => { + expectTypeOf(client.decryptModel).toBeCallableWith( + { id: 'u1', email: {} as Encrypted }, + users, + ) + }) +}) + +describe('typed v3 client — soundness', () => { + it('rejects a hand-rolled structural table (no brand / private field)', () => { + const fakeTable = { + tableName: 'users', + build: () => ({ tableName: 'users', columns: {} }), + } + client.encrypt('x', { + // @ts-expect-error - a structural object is not a registered branded v3 table + table: fakeTable, + column: users.email, + }) + }) + + it('rejects a column whose domain is not present in the table', () => { + // Plaintext is a string (valid for every `users` column domain) so the only + // error is the column itself failing the `ColumnsOf<typeof users>` constraint. + client.encrypt('x', { + table: users, + // @ts-expect-error - int4_ord column from `other` is not in ColumnsOf<typeof users> + column: other.weight, + }) + }) +}) diff --git a/packages/stack/__tests__/typed-client-v3.test.ts b/packages/stack/__tests__/typed-client-v3.test.ts new file mode 100644 index 00000000..96754cdc --- /dev/null +++ b/packages/stack/__tests__/typed-client-v3.test.ts @@ -0,0 +1,95 @@ +import { describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { + encryptedDateColumn, + encryptedTable, + encryptedTextColumn, + encryptedTimestamptzColumn, + typedClient, +} from '@/encryption/v3' + +const table = encryptedTable('t', { + when: encryptedTimestamptzColumn('when'), + note: encryptedTextColumn('note'), + // camelCase JS property → snake_case DB name: reconstruction must key by the + // JS property (how the decrypted row is keyed), not the DB column name. + createdOn: encryptedDateColumn('created_on'), +}) + +/** + * A minimal client stub whose model-decrypt methods resolve to a fixed + * `Result` payload. `typedClient` only `await`s these, so a plain Promise is a + * sufficient thenable. + */ +function fakeClient(data: Record<string, unknown>): EncryptionClient { + return { + decryptModel: () => Promise.resolve({ data }), + bulkDecryptModels: () => Promise.resolve({ data: [data] }), + } as unknown as EncryptionClient +} + +describe('typedClient — decrypt reconstruction', () => { + it('reconstructs Date columns from cast_as', async () => { + const client = typedClient( + fakeClient({ + when: '2020-01-02T03:04:05.000Z', + note: 'hi', + createdOn: '2026-07-01T00:00:00.000Z', + }), + table, + ) + + const result = await client.decryptModel({}, table) + expect(result.failure).toBeFalsy() + if (result.failure) return + + const data = result.data as Record<string, unknown> + expect(data.when).toBeInstanceOf(Date) + expect((data.when as Date).toISOString()).toBe('2020-01-02T03:04:05.000Z') + // Reconstructed by JS property (`createdOn`), though the DB column is + // `created_on` — a regression here would leave it an unparsed string. + expect(data.createdOn).toBeInstanceOf(Date) + expect((data.createdOn as Date).toISOString()).toBe( + '2026-07-01T00:00:00.000Z', + ) + expect(data.note).toBe('hi') // string column untouched + }) + + it('leaves null column values untouched', async () => { + const client = typedClient(fakeClient({ when: null, note: null }), table) + + const result = await client.decryptModel({}, table) + if (result.failure) return + + const data = result.data as Record<string, unknown> + expect(data.when).toBeNull() + expect(data.note).toBeNull() + }) + + it('reconstructs each row for bulkDecryptModels', async () => { + const client = typedClient( + fakeClient({ when: '2021-06-01T00:00:00.000Z', note: 'x' }), + table, + ) + + const result = await client.bulkDecryptModels([{}], table) + if (result.failure) return + + const rows = result.data as Array<Record<string, unknown>> + expect(rows).toHaveLength(1) + expect(rows[0].when).toBeInstanceOf(Date) + }) + + it('propagates a failure result unchanged', async () => { + const failing = { + decryptModel: () => + Promise.resolve({ + failure: { type: 'DecryptionError', message: 'boom' }, + }), + } as unknown as EncryptionClient + + const client = typedClient(failing, table) + const result = await client.decryptModel({}, table) + expect(result.failure).toBeTruthy() + }) +}) diff --git a/packages/stack/__tests__/wasm-inline-column-name.test.ts b/packages/stack/__tests__/wasm-inline-column-name.test.ts new file mode 100644 index 00000000..de96afd0 --- /dev/null +++ b/packages/stack/__tests__/wasm-inline-column-name.test.ts @@ -0,0 +1,46 @@ +import { describe, expect, it, vi } from 'vitest' + +// This unit test only covers `getColumnName`, which resolves a column's name +// structurally and never touches WASM. Mock the `/wasm-inline` specifiers so +// Vitest can load `../src/wasm-inline` without resolving the real inlined WASM +// entries (which aren't exported for the test bundler). +vi.mock('@cipherstash/auth/wasm-inline', () => ({ + AccessKeyStrategy: { + create: vi.fn(), + }, +})) + +vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ + decrypt: vi.fn(), + encrypt: vi.fn(), + isEncrypted: vi.fn(), + newClient: vi.fn(), +})) + +import { encryptedColumn, encryptedField } from '../src/schema' +import { encryptedTextSearchColumn } from '../src/schema/v3' +import { getColumnName } from '../src/wasm-inline' + +describe('wasm-inline getColumnName', () => { + it('returns the name for a v2 EncryptedColumn', () => { + expect(getColumnName(encryptedColumn('email'))).toBe('email') + }) + + it('returns the name for a v2 EncryptedField', () => { + expect(getColumnName(encryptedField('profile'))).toBe('profile') + }) + + it('returns the name for a v3 EncryptedTextSearchColumn (structural, no instanceof)', () => { + // Regression: widening EncryptOptions.column to the structural + // BuildableColumn made v3 columns type-check at the wasm-inline encrypt + // entry, but the old `instanceof EncryptedColumn || EncryptedField` gate + // threw at runtime. The entry now resolves the name structurally so a v3 + // column genuinely round-trips through WasmEncryptionClient.encrypt(). + expect(getColumnName(encryptedTextSearchColumn('email'))).toBe('email') + }) + + it('throws when given a value that does not expose getName()', () => { + // Plain JS callers can bypass the type system — guard at runtime. + expect(() => getColumnName({} as never)).toThrow(/getName/) + }) +}) diff --git a/packages/stack/__tests__/wasm-inline-strategy.test.ts b/packages/stack/__tests__/wasm-inline-strategy.test.ts index b082b9fd..84c2f1c2 100644 --- a/packages/stack/__tests__/wasm-inline-strategy.test.ts +++ b/packages/stack/__tests__/wasm-inline-strategy.test.ts @@ -58,6 +58,22 @@ describe('wasm-inline resolveStrategy', () => { expect(vi.mocked(AccessKeyStrategy.create)).not.toHaveBeenCalled() }) + it('throws when the access-key arm is missing workspaceCrn or accessKey', () => { + // JS callers bypass the compile-time union, so the no-strategy arm must + // reject a missing CRN or access key instead of forwarding `undefined` + // into `AccessKeyStrategy.create`. + expect(() => + // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid — no strategy, no accessKey + resolveStrategy({ workspaceCrn: CRN } as any), + ).toThrowError(/`config\.workspaceCrn` and `config\.accessKey` are required/) + expect(() => + // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid — no strategy, no workspaceCrn + resolveStrategy({ accessKey: 'CSAK.test' } as any), + ).toThrowError(/`config\.workspaceCrn` and `config\.accessKey` are required/) + // The guard must short-circuit *before* building a strategy. + expect(vi.mocked(AccessKeyStrategy.create)).not.toHaveBeenCalled() + }) + it('throws when both strategy and accessKey are supplied', () => { const both = { workspaceCrn: CRN, diff --git a/packages/stack/package.json b/packages/stack/package.json index 60c00c1c..9ce6281d 100644 --- a/packages/stack/package.json +++ b/packages/stack/package.json @@ -51,6 +51,12 @@ "schema": [ "./dist/schema/index.d.ts" ], + "schema/v3": [ + "./dist/schema/v3/index.d.ts" + ], + "v3": [ + "./dist/encryption/v3.d.ts" + ], "types": [ "./dist/types-public.d.ts" ], @@ -119,6 +125,26 @@ "default": "./dist/schema/index.cjs" } }, + "./schema/v3": { + "import": { + "types": "./dist/schema/v3/index.d.ts", + "default": "./dist/schema/v3/index.js" + }, + "require": { + "types": "./dist/schema/v3/index.d.cts", + "default": "./dist/schema/v3/index.cjs" + } + }, + "./v3": { + "import": { + "types": "./dist/encryption/v3.d.ts", + "default": "./dist/encryption/v3.js" + }, + "require": { + "types": "./dist/encryption/v3.d.cts", + "default": "./dist/encryption/v3.cjs" + } + }, "./types": { "import": { "types": "./dist/types-public.d.ts", @@ -191,7 +217,10 @@ "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"", "build": "tsup", "dev": "tsup --watch", + "analyze:complexity": "fta src/schema/v3 --score-cap 72", + "db:eql-v3:install": "tsx scripts/install-eql-v3.ts", "test": "vitest run", + "test:types": "vitest --run --typecheck.only", "release": "tsup" }, "devDependencies": { @@ -201,6 +230,7 @@ "dotenv": "17.4.2", "drizzle-orm": "^0.45.2", "execa": "^9.5.2", + "fta-cli": "3.0.0", "json-schema-to-typescript": "^15.0.2", "postgres": "^3.4.8", "tsup": "catalog:repo", diff --git a/packages/stack/scripts/install-eql-v3.ts b/packages/stack/scripts/install-eql-v3.ts new file mode 100644 index 00000000..e55eba79 --- /dev/null +++ b/packages/stack/scripts/install-eql-v3.ts @@ -0,0 +1,27 @@ +import { config } from 'dotenv' + +// Load env files in Next.js precedence order (.env.local wins over .env for the +// same key, since dotenv does not overwrite already-set vars). `quiet: true` +// suppresses dotenv v17's `injected env (N) from …` banner so this script does +// not print noisy, non-deterministic lines in CI. Mirrors the CLI entrypoint +// (packages/cli/src/bin/main.ts). +config({ path: '.env.local', quiet: true }) +config({ path: '.env.development.local', quiet: true }) +config({ path: '.env.development', quiet: true }) +config({ path: '.env', quiet: true }) + +import postgres from 'postgres' +import { installEqlV3IfNeeded } from '../__tests__/helpers/eql-v3' + +if (!process.env.DATABASE_URL) { + throw new Error('Missing env.DATABASE_URL') +} + +const sql = postgres(process.env.DATABASE_URL, { prepare: false }) + +try { + await installEqlV3IfNeeded(sql) + console.log('eql_v3.text_search is installed') +} finally { + await sql.end() +} diff --git a/packages/stack/src/encryption/helpers/infer-index-type.ts b/packages/stack/src/encryption/helpers/infer-index-type.ts index 80eaf6ad..fb6a9a54 100644 --- a/packages/stack/src/encryption/helpers/infer-index-type.ts +++ b/packages/stack/src/encryption/helpers/infer-index-type.ts @@ -1,13 +1,17 @@ -import type { JsPlaintext, QueryOpName } from '@cipherstash/protect-ffi' -import type { EncryptedColumn } from '@/schema' -import type { FfiIndexTypeName, QueryTypeName } from '../../types' +import type { QueryOpName } from '@cipherstash/protect-ffi' +import type { + BuildableQueryColumn, + FfiIndexTypeName, + Plaintext, + QueryTypeName, +} from '../../types' import { queryTypeToFfi, queryTypeToQueryOp } from '../../types' /** * Infer the primary index type from a column's configured indexes. * Priority: unique > match > ore > ste_vec (for scalar queries) */ -export function inferIndexType(column: EncryptedColumn): FfiIndexTypeName { +export function inferIndexType(column: BuildableQueryColumn): FfiIndexTypeName { const config = column.build() const indexes = config.indexes @@ -31,16 +35,16 @@ export function inferIndexType(column: EncryptedColumn): FfiIndexTypeName { * - String → ste_vec_selector (JSONPath queries like '$.user.email') * - Object/Array/Number/Boolean → ste_vec_term (containment queries) */ -export function inferQueryOpFromPlaintext(plaintext: JsPlaintext): QueryOpName { +export function inferQueryOpFromPlaintext(plaintext: Plaintext): QueryOpName { if (typeof plaintext === 'string') { return 'ste_vec_selector' } - // Objects, arrays, numbers, booleans are all valid JSONB containment values + // Objects (incl. Date), arrays, numbers, booleans are all valid JSONB + // containment values if ( typeof plaintext === 'object' || typeof plaintext === 'number' || - typeof plaintext === 'boolean' || - typeof plaintext === 'bigint' + typeof plaintext === 'boolean' ) { return 'ste_vec_term' } @@ -52,7 +56,7 @@ export function inferQueryOpFromPlaintext(plaintext: JsPlaintext): QueryOpName { * Validate that the specified index type is configured on the column */ export function validateIndexType( - column: EncryptedColumn, + column: BuildableQueryColumn, indexType: FfiIndexTypeName, ): void { const config = column.build() @@ -84,9 +88,9 @@ export function validateIndexType( * @throws Error if ste_vec is inferred but queryOp cannot be determined */ export function resolveIndexType( - column: EncryptedColumn, + column: BuildableQueryColumn, queryType?: QueryTypeName, - plaintext?: JsPlaintext | null, + plaintext?: Plaintext | null, ): { indexType: FfiIndexTypeName; queryOp?: QueryOpName } { const indexType = queryType ? queryTypeToFfi[queryType] diff --git a/packages/stack/src/encryption/helpers/model-helpers.ts b/packages/stack/src/encryption/helpers/model-helpers.ts index 1cf59d8d..17da7dc7 100644 --- a/packages/stack/src/encryption/helpers/model-helpers.ts +++ b/packages/stack/src/encryption/helpers/model-helpers.ts @@ -6,8 +6,7 @@ import { import { isEncryptedPayload } from '@/encryption/helpers' import type { AuditData } from '@/encryption/operations/base-operation' import type { Context } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { Client, Decrypted, Encrypted } from '@/types' +import type { BuildableTable, Client, Decrypted, Encrypted } from '@/types' /** * Sets a value at a nested path in an object, creating intermediate objects as needed. @@ -205,9 +204,35 @@ function prepareFieldsForDecryption<T extends Record<string, unknown>>( /** * Helper function to prepare fields for encryption */ +/** + * Resolve how a table's model fields map onto encrypt-config columns. + * + * `columnPaths` are the keys used to MATCH a user model's fields (the JS + * property names); `toColumnName` maps a matched field to the name the FFI / + * encrypt config is keyed by (the DB name). + * + * When a table exposes `buildColumnKeyMap()` (v3), those two can differ, so we + * match by property but address by DB name. Otherwise (v2) `build()` already + * keys columns by the property name, so both are that same key (identity map). + */ +export function resolveEncryptColumnMap(table: BuildableTable): { + columnPaths: string[] + toColumnName: (path: string) => string +} { + const keyMap = table.buildColumnKeyMap?.() + if (keyMap) { + return { + columnPaths: Object.keys(keyMap), + toColumnName: (path) => keyMap[path] ?? path, + } + } + const columnPaths = Object.keys(table.build().columns) + return { columnPaths, toColumnName: (path) => path } +} + function prepareFieldsForEncryption<T extends Record<string, unknown>>( model: T, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, ): { otherFields: Record<string, unknown> operationFields: Record<string, unknown> @@ -264,8 +289,8 @@ function prepareFieldsForEncryption<T extends Record<string, unknown>>( } } - // Get all column paths from the table schema - const columnPaths = Object.keys(table.build().columns) + // Get all column paths from the table schema (matched by JS property name). + const { columnPaths } = resolveEncryptColumnMap(table) processNestedFields(model, '', columnPaths) return { otherFields, operationFields, keyMap, nullFields } @@ -326,7 +351,7 @@ export async function decryptModelFields<T extends Record<string, unknown>>( */ export async function encryptModelFields( model: Record<string, unknown>, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, auditData?: AuditData, ): Promise<Record<string, unknown>> { @@ -337,12 +362,13 @@ export async function encryptModelFields( const { otherFields, operationFields, keyMap, nullFields } = prepareFieldsForEncryption(model, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = Object.entries(operationFields).map( ([key, value]) => ({ id: key, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), }), ) @@ -437,7 +463,7 @@ export async function decryptModelFieldsWithLockContext< */ export async function encryptModelFieldsWithLockContext( model: Record<string, unknown>, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, lockContext: Context, auditData?: AuditData, @@ -453,12 +479,13 @@ export async function encryptModelFieldsWithLockContext( const { otherFields, operationFields, keyMap, nullFields } = prepareFieldsForEncryption(model, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = Object.entries(operationFields).map( ([key, value]) => ({ id: key, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), lockContext, }), ) @@ -496,7 +523,7 @@ export async function encryptModelFieldsWithLockContext( */ function prepareBulkModelsForOperation<T extends Record<string, unknown>>( models: T[], - table?: EncryptedTable<EncryptedTableColumn>, + table?: BuildableTable, ): { otherFields: Record<string, unknown>[] operationFields: Record<string, unknown>[] @@ -560,8 +587,8 @@ function prepareBulkModelsForOperation<T extends Record<string, unknown>>( } if (table) { - // Get all column paths from the table schema - const columnPaths = Object.keys(table.build().columns) + // Get all column paths from the table schema (matched by JS property name). + const { columnPaths } = resolveEncryptColumnMap(table) processNestedFields(model, '', columnPaths) } else { // For decryption, process all encrypted fields @@ -622,7 +649,7 @@ function prepareBulkModelsForOperation<T extends Record<string, unknown>>( */ export async function bulkEncryptModels( models: Record<string, unknown>[], - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, auditData?: AuditData, ): Promise<Record<string, unknown>[]> { @@ -637,12 +664,13 @@ export async function bulkEncryptModels( const { otherFields, operationFields, keyMap, nullFields } = prepareBulkModelsForOperation(models, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = operationFields.flatMap((fields, modelIndex) => Object.entries(fields).map(([key, value]) => ({ id: `${modelIndex}-${key}`, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), })), ) @@ -831,7 +859,7 @@ export async function bulkDecryptModelsWithLockContext< */ export async function bulkEncryptModelsWithLockContext( models: Record<string, unknown>[], - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, lockContext: Context, auditData?: AuditData, @@ -847,12 +875,13 @@ export async function bulkEncryptModelsWithLockContext( const { otherFields, operationFields, keyMap, nullFields } = prepareBulkModelsForOperation(models, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = operationFields.flatMap((fields, modelIndex) => Object.entries(fields).map(([key, value]) => ({ id: `${modelIndex}-${key}`, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), lockContext, })), ) diff --git a/packages/stack/src/encryption/index.ts b/packages/stack/src/encryption/index.ts index ccf422e1..bf5a08ee 100644 --- a/packages/stack/src/encryption/index.ts +++ b/packages/stack/src/encryption/index.ts @@ -1,5 +1,5 @@ import { type Result, withResult } from '@byteslice/result' -import { type JsPlaintext, newClient } from '@cipherstash/protect-ffi' +import { newClient } from '@cipherstash/protect-ffi' import { validate as uuidValidate } from 'uuid' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' // `LockContext` is imported type-only so the TSDoc {@link} references in the @@ -8,8 +8,6 @@ import type { LockContext } from '@/identity' import { buildEncryptConfig, type EncryptConfig, - type EncryptedTable, - type EncryptedTableColumn, encryptConfigSchema, // Imported type-only for the TSDoc {@link} references in the comments below. type encryptedColumn, @@ -18,15 +16,17 @@ import { } from '@/schema' import type { AuthStrategy, + BuildableTable, BulkDecryptPayload, BulkEncryptPayload, Client, Encrypted, - EncryptedFromSchema, + EncryptedFromBuildableTable, EncryptionClientConfig, EncryptOptions, EncryptQueryOptions, KeysetIdentifier, + Plaintext, ScalarQueryTerm, } from '@/types' import { logger } from '@/utils/logger' @@ -207,7 +207,7 @@ export class EncryptionClient { * @see {@link LockContext} * @see {@link EncryptOperation} */ - encrypt(plaintext: JsPlaintext, opts: EncryptOptions): EncryptOperation { + encrypt(plaintext: Plaintext, opts: EncryptOptions): EncryptOperation { return new EncryptOperation(this.client, plaintext, opts) } @@ -265,7 +265,7 @@ export class EncryptionClient { * - Object/Array plaintext → `steVecTerm` (containment queries like `{ role: 'admin' }`) */ encryptQuery( - plaintext: JsPlaintext, + plaintext: Plaintext, opts: EncryptQueryOptions, ): EncryptQueryOperation @@ -276,12 +276,14 @@ export class EncryptionClient { encryptQuery(terms: readonly ScalarQueryTerm[]): BatchEncryptQueryOperation encryptQuery( - plaintextOrTerms: JsPlaintext | readonly ScalarQueryTerm[], + plaintextOrTerms: Plaintext | readonly ScalarQueryTerm[], opts?: EncryptQueryOptions, ): EncryptQueryOperation | BatchEncryptQueryOperation { - // Discriminate between ScalarQueryTerm[] and JsPlaintext (which can also be an array) - // using a type guard function - if (isScalarQueryTermArray(plaintextOrTerms)) { + // Discriminate between ScalarQueryTerm[] and Plaintext (which can also be an + // array) using a type guard function. Only route to batch mode when no opts + // are supplied — an explicit EncryptQueryOptions forces the single-plaintext + // path even if the plaintext value happens to be an array. + if (!opts && isScalarQueryTermArray(plaintextOrTerms)) { return new BatchEncryptQueryOperation(this.client, plaintextOrTerms) } @@ -305,7 +307,7 @@ export class EncryptionClient { return new EncryptQueryOperation( this.client, - plaintextOrTerms as JsPlaintext, + plaintextOrTerms as Plaintext, opts, ) } @@ -399,13 +401,10 @@ export class EncryptionClient { * } * ``` */ - encryptModel< - T extends Record<string, unknown>, - S extends EncryptedTableColumn = EncryptedTableColumn, - >( + encryptModel<T extends Record<string, unknown>, Table extends BuildableTable>( input: T, - table: EncryptedTable<S>, - ): EncryptModelOperation<EncryptedFromSchema<T, S>> { + table: Table, + ): EncryptModelOperation<EncryptedFromBuildableTable<T, Table>> { return new EncryptModelOperation( this.client, input as Record<string, unknown>, @@ -494,11 +493,11 @@ export class EncryptionClient { */ bulkEncryptModels< T extends Record<string, unknown>, - S extends EncryptedTableColumn = EncryptedTableColumn, + Table extends BuildableTable, >( input: Array<T>, - table: EncryptedTable<S>, - ): BulkEncryptModelsOperation<EncryptedFromSchema<T, S>> { + table: Table, + ): BulkEncryptModelsOperation<EncryptedFromBuildableTable<T, Table>> { return new BulkEncryptModelsOperation( this.client, input as Array<Record<string, unknown>>, diff --git a/packages/stack/src/encryption/operations/bulk-encrypt-models.ts b/packages/stack/src/encryption/operations/bulk-encrypt-models.ts index 20d68496..10c22633 100644 --- a/packages/stack/src/encryption/operations/bulk-encrypt-models.ts +++ b/packages/stack/src/encryption/operations/bulk-encrypt-models.ts @@ -2,8 +2,7 @@ import { type Result, withResult } from '@byteslice/result' import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { Client } from '@/types' +import type { BuildableTable, Client } from '@/types' import { createRequestLogger } from '@/utils/logger' import { bulkEncryptModels, @@ -17,12 +16,12 @@ export class BulkEncryptModelsOperation< > extends EncryptionOperation<T[]> { private client: Client private models: Record<string, unknown>[] - private table: EncryptedTable<EncryptedTableColumn> + private table: BuildableTable constructor( client: Client, models: Record<string, unknown>[], - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, ) { super() this.client = client @@ -76,7 +75,7 @@ export class BulkEncryptModelsOperation< public getOperation(): { client: Client models: Record<string, unknown>[] - table: EncryptedTable<EncryptedTableColumn> + table: BuildableTable } { return { client: this.client, diff --git a/packages/stack/src/encryption/operations/bulk-encrypt.ts b/packages/stack/src/encryption/operations/bulk-encrypt.ts index 9b01825a..6e3ec802 100644 --- a/packages/stack/src/encryption/operations/bulk-encrypt.ts +++ b/packages/stack/src/encryption/operations/bulk-encrypt.ts @@ -8,12 +8,8 @@ import { resolveLockContext, } from '@/identity' import type { - EncryptedColumn, - EncryptedField, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' -import type { + BuildableColumn, + BuildableTable, BulkEncryptedData, BulkEncryptPayload, Client, @@ -29,8 +25,8 @@ import { EncryptionOperation } from './base-operation' // re-inserted as null in `mapEncryptedDataToResult`. const createEncryptPayloads = ( plaintexts: BulkEncryptPayload, - column: EncryptedColumn | EncryptedField, - table: EncryptedTable<EncryptedTableColumn>, + column: BuildableColumn, + table: BuildableTable, lockContext?: Context, ) => { return plaintexts @@ -67,8 +63,8 @@ const mapEncryptedDataToResult = ( export class BulkEncryptOperation extends EncryptionOperation<BulkEncryptedData> { private client: Client private plaintexts: BulkEncryptPayload - private column: EncryptedColumn | EncryptedField - private table: EncryptedTable<EncryptedTableColumn> + private column: BuildableColumn + private table: BuildableTable constructor( client: Client, @@ -142,8 +138,8 @@ export class BulkEncryptOperation extends EncryptionOperation<BulkEncryptedData> public getOperation(): { client: Client plaintexts: BulkEncryptPayload - column: EncryptedColumn | EncryptedField - table: EncryptedTable<EncryptedTableColumn> + column: BuildableColumn + table: BuildableTable } { return { client: this.client, diff --git a/packages/stack/src/encryption/operations/encrypt-model.ts b/packages/stack/src/encryption/operations/encrypt-model.ts index 1c39d66e..0ac42f08 100644 --- a/packages/stack/src/encryption/operations/encrypt-model.ts +++ b/packages/stack/src/encryption/operations/encrypt-model.ts @@ -2,8 +2,7 @@ import { type Result, withResult } from '@byteslice/result' import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { Client } from '@/types' +import type { BuildableTable, Client } from '@/types' import { createRequestLogger } from '@/utils/logger' import { encryptModelFields, @@ -17,12 +16,12 @@ export class EncryptModelOperation< > extends EncryptionOperation<T> { private client: Client private model: Record<string, unknown> - private table: EncryptedTable<EncryptedTableColumn> + private table: BuildableTable constructor( client: Client, model: Record<string, unknown>, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, ) { super() this.client = client @@ -75,7 +74,7 @@ export class EncryptModelOperation< public getOperation(): { client: Client model: Record<string, unknown> - table: EncryptedTable<EncryptedTableColumn> + table: BuildableTable } { return { client: this.client, diff --git a/packages/stack/src/encryption/operations/encrypt-query.ts b/packages/stack/src/encryption/operations/encrypt-query.ts index c2c17b36..9369b91d 100644 --- a/packages/stack/src/encryption/operations/encrypt-query.ts +++ b/packages/stack/src/encryption/operations/encrypt-query.ts @@ -7,7 +7,12 @@ import { formatEncryptedResult } from '@/encryption/helpers' import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' -import type { Client, EncryptedQueryResult, EncryptQueryOptions } from '@/types' +import type { + Client, + EncryptedQueryResult, + EncryptQueryOptions, + Plaintext, +} from '@/types' import { createRequestLogger } from '@/utils/logger' import { resolveIndexType } from '../helpers/infer-index-type' import { @@ -20,7 +25,7 @@ import { EncryptionOperation } from './base-operation' export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryResult> { constructor( private client: Client, - private plaintext: JsPlaintext | null | undefined, + private plaintext: Plaintext | null | undefined, private opts: EncryptQueryOptions, ) { super() @@ -55,7 +60,7 @@ export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryRes return { data: null } } - const plaintext: JsPlaintext = this.plaintext + const plaintext: Plaintext = this.plaintext const validationError = validateNumericValue(plaintext) if (validationError?.failure) { @@ -83,7 +88,10 @@ export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryRes ) const encrypted = await ffiEncryptQuery(this.client, { - plaintext, + // `Plaintext` widens the FFI `JsPlaintext` with `Date` (serialized via + // `toJSON` at the boundary); cast until the upstream input union is + // corrected to include it. + plaintext: plaintext as JsPlaintext, column: this.opts.column.getName(), table: this.opts.table.tableName, indexType, @@ -114,7 +122,7 @@ export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryRes export class EncryptQueryOperationWithLockContext extends EncryptionOperation<EncryptedQueryResult> { constructor( private client: Client, - private plaintext: JsPlaintext | null | undefined, + private plaintext: Plaintext | null | undefined, private opts: EncryptQueryOptions, private lockContext: LockContextInput, auditMetadata?: Record<string, unknown>, @@ -140,7 +148,7 @@ export class EncryptQueryOperationWithLockContext extends EncryptionOperation<En return { data: null } } - const plaintext: JsPlaintext = this.plaintext + const plaintext: Plaintext = this.plaintext const validationError = validateNumericValue(plaintext) if (validationError?.failure) { @@ -170,7 +178,10 @@ export class EncryptQueryOperationWithLockContext extends EncryptionOperation<En ) const encrypted = await ffiEncryptQuery(this.client, { - plaintext, + // `Plaintext` widens the FFI `JsPlaintext` with `Date` (serialized via + // `toJSON` at the boundary); cast until the upstream input union is + // corrected to include it. + plaintext: plaintext as JsPlaintext, column: this.opts.column.getName(), table: this.opts.table.tableName, indexType, diff --git a/packages/stack/src/encryption/operations/encrypt.ts b/packages/stack/src/encryption/operations/encrypt.ts index 55ad7a30..eba1a278 100644 --- a/packages/stack/src/encryption/operations/encrypt.ts +++ b/packages/stack/src/encryption/operations/encrypt.ts @@ -7,12 +7,13 @@ import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' import type { - EncryptedColumn, - EncryptedField, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' -import type { Client, Encrypted, EncryptOptions } from '@/types' + BuildableColumn, + BuildableTable, + Client, + Encrypted, + EncryptOptions, + Plaintext, +} from '@/types' import { createRequestLogger } from '@/utils/logger' import { noClientError } from '../index' import { EncryptionOperation } from './base-operation' @@ -23,13 +24,13 @@ export class EncryptOperation extends EncryptionOperation<Encrypted> { // short-circuit. The public `Encryption.encrypt()` signature still // rejects null at the type layer; this is defense in depth for callers // that reach this class through casts or dynamic field walking. - private plaintext: JsPlaintext | null - private column: EncryptedColumn | EncryptedField - private table: EncryptedTable<EncryptedTableColumn> + private plaintext: Plaintext | null + private column: BuildableColumn + private table: BuildableTable constructor( client: Client, - plaintext: JsPlaintext | null, + plaintext: Plaintext | null, opts: EncryptOptions, ) { super() @@ -87,7 +88,10 @@ export class EncryptOperation extends EncryptionOperation<Encrypted> { const { metadata } = this.getAuditData() return await ffiEncrypt(this.client, { - plaintext: this.plaintext, + // `Plaintext` widens the FFI `JsPlaintext` with `Date` (serialized via + // `toJSON` at the boundary); cast until the upstream `JsPlaintext` input + // union is corrected to include it. + plaintext: this.plaintext as JsPlaintext, column: this.column.getName(), table: this.table.tableName, unverifiedContext: metadata, @@ -108,9 +112,9 @@ export class EncryptOperation extends EncryptionOperation<Encrypted> { public getOperation(): { client: Client - plaintext: JsPlaintext | null - column: EncryptedColumn | EncryptedField - table: EncryptedTable<EncryptedTableColumn> + plaintext: Plaintext | null + column: BuildableColumn + table: BuildableTable } { return { client: this.client, @@ -156,11 +160,19 @@ export class EncryptOperationWithLockContext extends EncryptionOperation<Encrypt return null as unknown as Encrypted } + if (typeof plaintext === 'number' && Number.isNaN(plaintext)) { + throw new Error('[encryption]: Cannot encrypt NaN value') + } + + if (typeof plaintext === 'number' && !Number.isFinite(plaintext)) { + throw new Error('[encryption]: Cannot encrypt Infinity value') + } + const { metadata } = this.getAuditData() const lockContext = resolveLockContext(this.lockContext) return await ffiEncrypt(client, { - plaintext, + plaintext: plaintext as JsPlaintext, column: column.getName(), table: table.tableName, lockContext, diff --git a/packages/stack/src/encryption/v3.ts b/packages/stack/src/encryption/v3.ts new file mode 100644 index 00000000..bff929f7 --- /dev/null +++ b/packages/stack/src/encryption/v3.ts @@ -0,0 +1,225 @@ +import type { Result } from '@byteslice/result' +import type { EncryptionError } from '@/errors' +import type { LockContextInput } from '@/identity' +import type { + AnyV3Table, + ColumnsOf, + PlaintextForColumn, + QueryableColumnsOf, + QueryTypesForColumn, + V3DecryptedModel, + V3EncryptedModel, + V3ModelInput, +} from '@/schema/v3' +import type { + BulkDecryptPayload, + BulkEncryptPayload, + ClientConfig, + Encrypted, + EncryptedReturnType, + EncryptOptions, +} from '@/types' +import { + type BulkDecryptOperation, + type BulkEncryptModelsOperation, + type BulkEncryptOperation, + type DecryptOperation, + Encryption, + type EncryptionClient, + type EncryptModelOperation, + type EncryptOperation, + type EncryptQueryOperation, +} from './index' + +/** + * A strongly-typed view over an {@link EncryptionClient} for EQL v3 schemas. + * + * Every method derives its types from the concrete `table` / `column` builder + * arguments (which carry their branded types at the call site), so: + * - `encrypt` / `encryptQuery` pin the plaintext to the column's domain type + * (`text → string`, `timestamptz → Date`, …); + * - `encryptQuery` additionally constrains `queryType` to the column's + * capabilities and rejects storage-only columns outright; + * - `encryptModel` / `bulkEncryptModels` validate schema-column fields against + * their inferred plaintext type (passthrough fields are untouched) and return + * a precise encrypted model; + * - `decryptModel` / `bulkDecryptModels` return the precise plaintext model, + * reconstructing `Date` values from the encrypt-config `cast_as`. + * + * @typeParam S - the tuple of registered v3 tables; `table` arguments must be a + * member of this tuple. + */ +export interface TypedEncryptionClient<S extends readonly AnyV3Table[]> { + encrypt<Table extends S[number], Col extends ColumnsOf<Table>>( + plaintext: PlaintextForColumn<Col>, + opts: { table: Table; column: Col }, + ): EncryptOperation + + encryptQuery< + Table extends S[number], + Col extends QueryableColumnsOf<Table>, + QT extends QueryTypesForColumn<Col> = QueryTypesForColumn<Col>, + >( + plaintext: PlaintextForColumn<Col>, + opts: { + table: Table + column: Col + queryType?: QT + returnType?: EncryptedReturnType + }, + ): EncryptQueryOperation + + encryptModel<Table extends S[number], T extends Record<string, unknown>>( + input: V3ModelInput<Table, T>, + table: Table, + ): EncryptModelOperation<V3EncryptedModel<Table, T>> + + bulkEncryptModels<Table extends S[number], T extends Record<string, unknown>>( + input: Array<V3ModelInput<Table, T>>, + table: Table, + ): BulkEncryptModelsOperation<V3EncryptedModel<Table, T>> + + /** + * Decrypt a single value. Cannot be strongly typed — a lone ciphertext carries + * no column identity — so it resolves to the FFI plaintext union unchanged. + */ + decrypt(encrypted: Encrypted): DecryptOperation + + /** + * Decrypt a model, returning the precise plaintext shape for `table`. `Date` + * columns are reconstructed from the encrypt-config `cast_as`. + * + * Pass `lockContext` to decrypt identity-bound data — the same context that + * was supplied at encrypt time must be provided here. + * + * Unlike the encrypt operations this returns a plain `Promise<Result<…>>` + * rather than a chainable operation, because it maps the resolved value. + */ + decryptModel<Table extends S[number], T extends Record<string, unknown>>( + input: T, + table: Table, + lockContext?: LockContextInput, + ): Promise<Result<V3DecryptedModel<Table, T>, EncryptionError>> + + bulkDecryptModels<Table extends S[number], T extends Record<string, unknown>>( + input: Array<T>, + table: Table, + lockContext?: LockContextInput, + ): Promise<Result<Array<V3DecryptedModel<Table, T>>, EncryptionError>> + + // Parity passthroughs — not v3-strengthened, delegated as-is. + bulkEncrypt( + plaintexts: BulkEncryptPayload, + opts: EncryptOptions, + ): BulkEncryptOperation + bulkDecrypt(payloads: BulkDecryptPayload): BulkDecryptOperation + getEncryptConfig(): ReturnType<EncryptionClient['getEncryptConfig']> +} + +/** + * Reconstruct `Date` values on a decrypted row from the table's encrypt-config + * `cast_as`. The FFI returns `JsPlaintext` (string/number/boolean/…) with no + * `Date`, so those columns arrive as their serialized form and are rebuilt here. + * Safe (idempotent) if the FFI ever returns `Date` directly: `new Date(date)` is + * a no-op. + * + * NOTE: `bigint` (int8) reconstruction is intentionally absent — int8 domains are + * omitted from the v3 SDK until the native FFI supports lossless bigint I/O. + */ +function reconstructRow( + row: Record<string, unknown>, + table: AnyV3Table, +): Record<string, unknown> { + // The decrypted row is keyed by JS property name, but `cast_as` lives on the + // config keyed by DB name — bridge the two via the table's property→DB map. + const { columns } = table.build() + const propToDb = table.buildColumnKeyMap() + const out: Record<string, unknown> = { ...row } + for (const [property, dbName] of Object.entries(propToDb)) { + const value = out[property] + if (value == null) continue + if (columns[dbName]?.cast_as === 'date') { + out[property] = new Date(value as string | number | Date) + } + } + return out +} + +/** + * Wrap an already-built {@link EncryptionClient} in a {@link TypedEncryptionClient} + * for the given v3 schemas. Zero runtime cost for the encrypt/query paths (the + * underlying operations are returned unchanged); the decrypt-model paths add a + * per-column `Date` reconstruction step. + * + * The `schemas` are captured with a `const` type parameter so array-literal + * widening does not collapse per-table inference. + */ +export function typedClient<const S extends readonly AnyV3Table[]>( + client: EncryptionClient, + ..._schemas: S +): TypedEncryptionClient<S> { + return { + encrypt: (plaintext, opts) => + client.encrypt(plaintext as never, opts as never), + encryptQuery: (plaintext, opts) => + client.encryptQuery(plaintext as never, opts as never), + encryptModel: (input, table) => + client.encryptModel(input as never, table as never) as never, + bulkEncryptModels: (input, table) => + client.bulkEncryptModels(input as never, table as never) as never, + decrypt: (encrypted) => client.decrypt(encrypted), + decryptModel: async (input, table, lockContext) => { + const op = client.decryptModel(input as never) + const result = await (lockContext ? op.withLockContext(lockContext) : op) + if (result.failure) return result as never + return { data: reconstructRow(result.data, table) } as never + }, + bulkDecryptModels: async (input, table, lockContext) => { + const op = client.bulkDecryptModels(input as never) + const result = await (lockContext ? op.withLockContext(lockContext) : op) + if (result.failure) return result as never + return { + data: result.data.map((row) => + reconstructRow(row as Record<string, unknown>, table), + ), + } as never + }, + bulkEncrypt: (plaintexts, opts) => client.bulkEncrypt(plaintexts, opts), + bulkDecrypt: (payloads) => client.bulkDecrypt(payloads), + getEncryptConfig: () => client.getEncryptConfig(), + } satisfies TypedEncryptionClient<S> +} + +/** + * Build a {@link TypedEncryptionClient} for EQL v3 schemas — the strongly-typed + * counterpart to {@link Encryption}. Mirrors its config, then retypes the client + * against the provided v3 `schemas`. + * + * @example + * ```typescript + * import { EncryptionV3, encryptedTable, encryptedTextSearchColumn } from "@cipherstash/stack/v3" + * + * const users = encryptedTable("users", { email: encryptedTextSearchColumn("email") }) + * const client = await EncryptionV3({ schemas: [users] }) + * + * await client.encrypt("a@b.com", { table: users, column: users.email }) + * ``` + */ +export async function EncryptionV3< + const S extends readonly AnyV3Table[], +>(config: { + schemas: S + config?: ClientConfig +}): Promise<TypedEncryptionClient<S>> { + const client = await Encryption({ + schemas: config.schemas as unknown as Parameters< + typeof Encryption + >[0]['schemas'], + config: config.config, + }) + return typedClient(client, ...config.schemas) +} + +// Single import surface: re-export the v3 builders + type helpers so +// `@cipherstash/stack/v3` provides everything needed to author and use a schema. +export * from '@/schema/v3' diff --git a/packages/stack/src/identity/index.ts b/packages/stack/src/identity/index.ts index a1197321..4497253b 100644 --- a/packages/stack/src/identity/index.ts +++ b/packages/stack/src/identity/index.ts @@ -39,7 +39,12 @@ export type LockContextInput = LockContext | Context * that protect-ffi expects. Synchronous — no token round-trip. */ export function resolveLockContext(input: LockContextInput): Context { - return input instanceof LockContext ? input.identityContext : input + // Use a structural check as well as `instanceof` so a `LockContext` + // constructed in another realm (or from a duplicate module instance) is still + // resolved rather than slipping through as a raw `Context`. + return input instanceof LockContext || 'identityContext' in input + ? (input as LockContext).identityContext + : input } /** diff --git a/packages/stack/src/schema/index.ts b/packages/stack/src/schema/index.ts index 48181f12..01058cc6 100644 --- a/packages/stack/src/schema/index.ts +++ b/packages/stack/src/schema/index.ts @@ -1,5 +1,5 @@ import { z } from 'zod' -import type { Encrypted } from '@/types' +import type { BuildableTable, Encrypted } from '@/types' // ------------------------ // Zod schemas @@ -678,7 +678,7 @@ export function encryptedField(valueName: string) { * ``` */ export function buildEncryptConfig( - ...protectTables: Array<EncryptedTable<EncryptedTableColumn>> + ...protectTables: Array<BuildableTable> ): EncryptConfig { const config: EncryptConfig = { v: 1, diff --git a/packages/stack/src/schema/v3/index.ts b/packages/stack/src/schema/v3/index.ts new file mode 100644 index 00000000..c1f732aa --- /dev/null +++ b/packages/stack/src/schema/v3/index.ts @@ -0,0 +1,992 @@ +import type { ColumnSchema, EncryptConfig, MatchIndexOpts } from '@/schema' +import type { Encrypted } from '@/types' + +/** + * The query capabilities a v3 concrete domain exposes. These are SDK-facing + * semantic flags describing what kinds of query terms a column can produce — + * NOT the raw EQL index keys. They are metadata only and never emitted by + * `build()`. + * + * - `equality`: exact-match lookups (EQL `hm`, or comparison via `ob`). + * - `orderAndRange`: comparison / range lookups (EQL `ob`). + * - `freeTextSearch`: tokenised substring match (EQL `bf`). + */ +export type QueryCapabilities = Readonly<{ + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean +}> + +/** The plaintext (TypeScript) kind a v3 domain decrypts to. A subset of the + * SDK `CastAs` enum, restricted to the scalar kinds v3 domains actually use. */ +type PlaintextKind = 'string' | 'number' | 'boolean' | 'date' + +/** + * The full, literal definition of a v3 domain. This is the LOAD-BEARING type: + * the base column class carries a private field of this type so that every + * concrete (otherwise-empty) subclass is discriminated by its literal + * `eqlType`/`castAs`/`capabilities` — TypeScript empty subclasses are NOT + * nominal, so without this a storage-only `bool` column would be assignable to + * a storage-only `date` column and plaintext inference would collapse. + */ +type V3DomainDefinition = Readonly<{ + eqlType: `eql_v3.${string}` + castAs: PlaintextKind + capabilities: QueryCapabilities +}> + +/** Type-level mirror of {@link isQueryableCapabilities}: `false` for a + * storage-only domain (all capability flags `false`), `true` otherwise. */ +type QueryableFlag<D extends V3DomainDefinition> = D['capabilities'] extends { + equality: false + orderAndRange: false + freeTextSearch: false +} + ? false + : true + +const STORAGE_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: false, +} as const + +const EQUALITY_ONLY = { + equality: true, + orderAndRange: false, + freeTextSearch: false, +} as const + +const ORDER_AND_RANGE = { + equality: true, + orderAndRange: true, + freeTextSearch: false, +} as const + +const MATCH_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: true, +} as const + +const TEXT_SEARCH = { + equality: true, + orderAndRange: true, + freeTextSearch: true, +} as const + +/** + * The concrete EQL v3 domain name for a full-capability text column. + * Recorded as metadata for future DDL / query-dialect increments; it is + * intentionally absent from the emitted encrypt config. + */ +export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' + +// Per-domain literal definitions. Each concrete column subclass is parameterised +// by `typeof <CONST>`; the literal `eqlType`/`castAs`/`capabilities` on each is +// what makes the otherwise-empty subclasses nominally distinct (see +// V3DomainDefinition). Order mirrors eql-bindings `CATALOG` order. +const INT4 = { + eqlType: 'eql_v3.int4', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +const INT4_EQ = { + eqlType: 'eql_v3.int4_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +const INT4_ORD_ORE = { + eqlType: 'eql_v3.int4_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +const INT4_ORD = { + eqlType: 'eql_v3.int4_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +const INT2 = { + eqlType: 'eql_v3.int2', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +const INT2_EQ = { + eqlType: 'eql_v3.int2_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +const INT2_ORD_ORE = { + eqlType: 'eql_v3.int2_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +const INT2_ORD = { + eqlType: 'eql_v3.int2_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. + +const DATE = { + eqlType: 'eql_v3.date', + castAs: 'date', + capabilities: STORAGE_ONLY, +} as const +const DATE_EQ = { + eqlType: 'eql_v3.date_eq', + castAs: 'date', + capabilities: EQUALITY_ONLY, +} as const +const DATE_ORD_ORE = { + eqlType: 'eql_v3.date_ord_ore', + castAs: 'date', + capabilities: ORDER_AND_RANGE, +} as const +const DATE_ORD = { + eqlType: 'eql_v3.date_ord', + castAs: 'date', + capabilities: ORDER_AND_RANGE, +} as const + +const TIMESTAMPTZ = { + eqlType: 'eql_v3.timestamptz', + castAs: 'date', + capabilities: STORAGE_ONLY, +} as const +const TIMESTAMPTZ_EQ = { + eqlType: 'eql_v3.timestamptz_eq', + castAs: 'date', + capabilities: EQUALITY_ONLY, +} as const +const TIMESTAMPTZ_ORD_ORE = { + eqlType: 'eql_v3.timestamptz_ord_ore', + castAs: 'date', + capabilities: ORDER_AND_RANGE, +} as const +const TIMESTAMPTZ_ORD = { + eqlType: 'eql_v3.timestamptz_ord', + castAs: 'date', + capabilities: ORDER_AND_RANGE, +} as const + +const NUMERIC = { + eqlType: 'eql_v3.numeric', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +const NUMERIC_EQ = { + eqlType: 'eql_v3.numeric_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +const NUMERIC_ORD_ORE = { + eqlType: 'eql_v3.numeric_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +const NUMERIC_ORD = { + eqlType: 'eql_v3.numeric_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +const TEXT = { + eqlType: 'eql_v3.text', + castAs: 'string', + capabilities: STORAGE_ONLY, +} as const +const TEXT_EQ = { + eqlType: 'eql_v3.text_eq', + castAs: 'string', + capabilities: EQUALITY_ONLY, +} as const +const TEXT_MATCH = { + eqlType: 'eql_v3.text_match', + castAs: 'string', + capabilities: MATCH_ONLY, +} as const +const TEXT_ORD_ORE = { + eqlType: 'eql_v3.text_ord_ore', + castAs: 'string', + capabilities: ORDER_AND_RANGE, +} as const +const TEXT_ORD = { + eqlType: 'eql_v3.text_ord', + castAs: 'string', + capabilities: ORDER_AND_RANGE, +} as const + +const BOOL = { + eqlType: 'eql_v3.bool', + castAs: 'boolean', + capabilities: STORAGE_ONLY, +} as const + +const FLOAT4 = { + eqlType: 'eql_v3.float4', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +const FLOAT4_EQ = { + eqlType: 'eql_v3.float4_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +const FLOAT4_ORD_ORE = { + eqlType: 'eql_v3.float4_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +const FLOAT4_ORD = { + eqlType: 'eql_v3.float4_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +const FLOAT8 = { + eqlType: 'eql_v3.float8', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +const FLOAT8_EQ = { + eqlType: 'eql_v3.float8_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +const FLOAT8_ORD_ORE = { + eqlType: 'eql_v3.float8_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +const FLOAT8_ORD = { + eqlType: 'eql_v3.float8_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +/** + * Fully-resolved match-index options: every field present and non-`undefined`. + * + * `MatchIndexOpts` (the user-facing tuning input) has all fields optional — + * each is `.default(...).optional()` in the zod schema, so its inferred type is + * `T | undefined`. This type pins the BUILT/resolved shape explicitly via + * `NonNullable<...>`, which states the non-null intent directly and is robust + * regardless of `Required<>`'s subtle, `exactOptionalPropertyTypes`-dependent + * stripping semantics. (v2 uses `Required<MatchIndexOpts>` and that compiles + * fine under this repo's tsconfig — `strict: true`, NO `exactOptionalPropertyTypes` + * — so this is a clarity/robustness choice, not a fix for a present break.) + */ +type BuiltMatchIndexOpts = { + tokenizer: NonNullable<MatchIndexOpts['tokenizer']> + token_filters: NonNullable<MatchIndexOpts['token_filters']> + k: NonNullable<MatchIndexOpts['k']> + m: NonNullable<MatchIndexOpts['m']> + include_original: NonNullable<MatchIndexOpts['include_original']> +} + +/** + * Default match-index parameters. These mirror the v2 `freeTextSearch()` + * builder defaults EXACTLY (note `include_original: true`, which is the v2 + * builder default rather than the zod-schema default of `false`). + * + * This is a FACTORY (not a shared `const`) so every caller gets fresh, unaliased + * nested objects (`tokenizer`, `token_filters` and the `{ kind: 'downcase' }` + * inside it). A shared const would be shallow-copied by `{ ...DEFAULT }`, leaving + * those nested objects aliased across every column — a caller mutating one built + * config could then corrupt the defaults used by later columns. + */ +function defaultMatchOpts(): BuiltMatchIndexOpts { + return { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + } +} + +/** + * Translate a domain's semantic {@link QueryCapabilities} into the concrete EQL + * index block emitted by `build()`. + * + * - equality WITHOUT order/range → `unique` (the `hm` HMAC index). + * - order/range → `ore` ONLY. The EQL `ob` key supports both equality and + * range, so an order-capable column does NOT also emit `unique`. + * - free-text search → `match` (the `bf` bloom-filter index), deep-cloned from + * the per-call defaults so no nested object is ever shared across columns. + */ +function indexesForCapabilities( + capabilities: QueryCapabilities, +): ColumnSchema['indexes'] { + const indexes: ColumnSchema['indexes'] = {} + + if (capabilities.equality && !capabilities.orderAndRange) { + indexes.unique = { token_filters: [] } + } + + if (capabilities.orderAndRange) { + indexes.ore = {} + } + + if (capabilities.freeTextSearch) { + const match = defaultMatchOpts() + indexes.match = { + ...match, + tokenizer: { ...match.tokenizer }, + token_filters: match.token_filters.map((f) => ({ ...f })), + } + } + + return indexes +} + +/** Whether a domain's capabilities make it queryable at all (any flag set). */ +function isQueryableCapabilities(capabilities: QueryCapabilities): boolean { + return ( + capabilities.equality || + capabilities.orderAndRange || + capabilities.freeTextSearch + ) +} + +/** + * Shared base for every v3 concrete domain column. Parameterised by the FULL + * literal {@link V3DomainDefinition} (not by capabilities alone): the private + * `definition` field carries the literal `eqlType`/`castAs`/`capabilities`, so + * two otherwise-empty subclasses (e.g. `EncryptedBoolColumn` and + * `EncryptedDateColumn`, both storage-only) are NOT mutually assignable. This + * nominality is what keeps plaintext inference precise. + */ +class EncryptedV3Column<D extends V3DomainDefinition> { + constructor( + private readonly columnName: string, + private readonly definition: D, + ) {} + + getName(): string { + return this.columnName + } + + /** The concrete EQL v3 domain name. Metadata only; not emitted by `build()`. */ + getEqlType(): D['eqlType'] { + return this.definition.eqlType + } + + /** The semantic query capabilities this domain exposes. Metadata only. */ + getQueryCapabilities(): D['capabilities'] { + return this.definition.capabilities + } + + /** `true` when this domain can produce at least one kind of query term. */ + isQueryable(): QueryableFlag<D> { + return isQueryableCapabilities( + this.definition.capabilities, + ) as QueryableFlag<D> + } + + /** Emit the encrypt-config column: `cast_as` plus capability-derived indexes. */ + build(): ColumnSchema { + return { + cast_as: this.definition.castAs, + indexes: indexesForCapabilities(this.definition.capabilities), + } + } +} + +const TEXT_SEARCH_DOMAIN = { + eqlType: TEXT_SEARCH_EQL_TYPE, + castAs: 'string', + capabilities: TEXT_SEARCH, +} as const + +/** + * Builder for an `eql_v3.text_search` column. + * + * The concrete type inherently enables equality + order/range + free-text + * match — there are no capability-enabling methods. `.freeTextSearch(opts?)` + * tunes the match index only. + * + * NOTE — querying: a `text_search` column emits all three indexes (`unique`, + * `ore`, `match`), and the shared index-inference picks them by fixed priority + * `unique > match > ore`. So `encryptQuery(value, { column, table })` with NO + * explicit `queryType` builds an EQUALITY term (via `unique`), NOT a free-text + * match — a substring like `'joh'` then matches nothing. To run a free-text + * match query you MUST pass `queryType: 'freeTextSearch'`: + * + * ```typescript + * // equality (default): exact value only + * client.encryptQuery('john@example.com', { column: users.email, table: users }) + * // free-text match: substring/token search + * client.encryptQuery('joh', { column: users.email, table: users, queryType: 'freeTextSearch' }) + * ``` + */ +export class EncryptedTextSearchColumn extends EncryptedV3Column< + typeof TEXT_SEARCH_DOMAIN +> { + private matchOpts: BuiltMatchIndexOpts + + constructor(columnName: string) { + super(columnName, TEXT_SEARCH_DOMAIN) + this.matchOpts = defaultMatchOpts() + } + + /** + * Tune the match index. Each provided key replaces its default; omitted + * keys keep the default. This NEVER enables a capability — match is always + * on for this type. Merge semantics mirror v2's `opts?.x ?? default`. + */ + freeTextSearch(opts?: MatchIndexOpts): this { + // A fresh defaults object per call supplies the `?? ` fallbacks, so no + // nested default object is ever shared into `this.matchOpts` by reference. + const defaults = defaultMatchOpts() + // Clone-on-write: deep-copy the nested tokenizer / token_filters when + // storing them so a caller mutating their own opts object between + // freeTextSearch(opts) and build() cannot leak into the emitted config. + const tokenizer = opts?.tokenizer ?? defaults.tokenizer + const token_filters = opts?.token_filters ?? defaults.token_filters + this.matchOpts = { + tokenizer: { ...tokenizer }, + token_filters: token_filters.map((f) => ({ ...f })), + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + } + return this + } + + /** Emit the encrypt-config column. Byte-identical to a v2 equality+order+match column. */ + override build(): ColumnSchema { + // Deep-clone the match block so the returned config NEVER aliases this + // builder's internal `matchOpts` (or any caller-supplied opts merged into + // it). A caller mutating the returned object cannot corrupt this builder's + // state or another column's defaults. + return { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + ...this.matchOpts, + tokenizer: { ...this.matchOpts.tokenizer }, + token_filters: this.matchOpts.token_filters.map((f) => ({ ...f })), + }, + }, + } + } +} + +/** + * Define an `eql_v3.text_search` column. The concrete type carries all three + * capabilities (equality + order/range + free-text match). Chain + * `.freeTextSearch(opts)` to tune the match index. + * + * Querying defaults to EQUALITY — pass `queryType: 'freeTextSearch'` to + * `encryptQuery` for free-text match. See {@link EncryptedTextSearchColumn}. + */ +export function encryptedTextSearchColumn( + columnName: string, +): EncryptedTextSearchColumn { + return new EncryptedTextSearchColumn(columnName) +} + +// --------------------------------------------------------------------------- +// Concrete domain columns and builders +// +// Every concrete class is an empty subclass parameterised by its literal domain +// definition (see EncryptedV3Column). The paired builder passes the SAME literal +// constant so the instance's private `definition` field carries full literal +// type data — that is what keeps distinct domains nominally incompatible. +// --------------------------------------------------------------------------- + +// int4 +export class EncryptedInt4Column extends EncryptedV3Column<typeof INT4> {} +export const encryptedInt4Column = (columnName: string) => + new EncryptedInt4Column(columnName, INT4) + +export class EncryptedInt4EqColumn extends EncryptedV3Column<typeof INT4_EQ> {} +export const encryptedInt4EqColumn = (columnName: string) => + new EncryptedInt4EqColumn(columnName, INT4_EQ) + +export class EncryptedInt4OrdOreColumn extends EncryptedV3Column< + typeof INT4_ORD_ORE +> {} +export const encryptedInt4OrdOreColumn = (columnName: string) => + new EncryptedInt4OrdOreColumn(columnName, INT4_ORD_ORE) + +export class EncryptedInt4OrdColumn extends EncryptedV3Column< + typeof INT4_ORD +> {} +export const encryptedInt4OrdColumn = (columnName: string) => + new EncryptedInt4OrdColumn(columnName, INT4_ORD) + +// int2 +export class EncryptedInt2Column extends EncryptedV3Column<typeof INT2> {} +export const encryptedInt2Column = (columnName: string) => + new EncryptedInt2Column(columnName, INT2) + +export class EncryptedInt2EqColumn extends EncryptedV3Column<typeof INT2_EQ> {} +export const encryptedInt2EqColumn = (columnName: string) => + new EncryptedInt2EqColumn(columnName, INT2_EQ) + +export class EncryptedInt2OrdOreColumn extends EncryptedV3Column< + typeof INT2_ORD_ORE +> {} +export const encryptedInt2OrdOreColumn = (columnName: string) => + new EncryptedInt2OrdOreColumn(columnName, INT2_ORD_ORE) + +export class EncryptedInt2OrdColumn extends EncryptedV3Column< + typeof INT2_ORD +> {} +export const encryptedInt2OrdColumn = (columnName: string) => + new EncryptedInt2OrdColumn(columnName, INT2_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<typeof DATE> {} +export const encryptedDateColumn = (columnName: string) => + new EncryptedDateColumn(columnName, DATE) + +export class EncryptedDateEqColumn extends EncryptedV3Column<typeof DATE_EQ> {} +export const encryptedDateEqColumn = (columnName: string) => + new EncryptedDateEqColumn(columnName, DATE_EQ) + +export class EncryptedDateOrdOreColumn extends EncryptedV3Column< + typeof DATE_ORD_ORE +> {} +export const encryptedDateOrdOreColumn = (columnName: string) => + new EncryptedDateOrdOreColumn(columnName, DATE_ORD_ORE) + +export class EncryptedDateOrdColumn extends EncryptedV3Column< + typeof DATE_ORD +> {} +export const encryptedDateOrdColumn = (columnName: string) => + new EncryptedDateOrdColumn(columnName, DATE_ORD) + +// timestamptz +export class EncryptedTimestamptzColumn extends EncryptedV3Column< + typeof TIMESTAMPTZ +> {} +export const encryptedTimestamptzColumn = (columnName: string) => + new EncryptedTimestamptzColumn(columnName, TIMESTAMPTZ) + +export class EncryptedTimestamptzEqColumn extends EncryptedV3Column< + typeof TIMESTAMPTZ_EQ +> {} +export const encryptedTimestamptzEqColumn = (columnName: string) => + new EncryptedTimestamptzEqColumn(columnName, TIMESTAMPTZ_EQ) + +export class EncryptedTimestamptzOrdOreColumn extends EncryptedV3Column< + typeof TIMESTAMPTZ_ORD_ORE +> {} +export const encryptedTimestamptzOrdOreColumn = (columnName: string) => + new EncryptedTimestamptzOrdOreColumn(columnName, TIMESTAMPTZ_ORD_ORE) + +export class EncryptedTimestamptzOrdColumn extends EncryptedV3Column< + typeof TIMESTAMPTZ_ORD +> {} +export const encryptedTimestamptzOrdColumn = (columnName: string) => + new EncryptedTimestamptzOrdColumn(columnName, TIMESTAMPTZ_ORD) + +// numeric +export class EncryptedNumericColumn extends EncryptedV3Column<typeof NUMERIC> {} +export const encryptedNumericColumn = (columnName: string) => + new EncryptedNumericColumn(columnName, NUMERIC) + +export class EncryptedNumericEqColumn extends EncryptedV3Column< + typeof NUMERIC_EQ +> {} +export const encryptedNumericEqColumn = (columnName: string) => + new EncryptedNumericEqColumn(columnName, NUMERIC_EQ) + +export class EncryptedNumericOrdOreColumn extends EncryptedV3Column< + typeof NUMERIC_ORD_ORE +> {} +export const encryptedNumericOrdOreColumn = (columnName: string) => + new EncryptedNumericOrdOreColumn(columnName, NUMERIC_ORD_ORE) + +export class EncryptedNumericOrdColumn extends EncryptedV3Column< + typeof NUMERIC_ORD +> {} +export const encryptedNumericOrdColumn = (columnName: string) => + new EncryptedNumericOrdColumn(columnName, NUMERIC_ORD) + +// text (text_search stays defined above with its match-tuning override) +export class EncryptedTextColumn extends EncryptedV3Column<typeof TEXT> {} +export const encryptedTextColumn = (columnName: string) => + new EncryptedTextColumn(columnName, TEXT) + +export class EncryptedTextEqColumn extends EncryptedV3Column<typeof TEXT_EQ> {} +export const encryptedTextEqColumn = (columnName: string) => + new EncryptedTextEqColumn(columnName, TEXT_EQ) + +export class EncryptedTextMatchColumn extends EncryptedV3Column< + typeof TEXT_MATCH +> {} +export const encryptedTextMatchColumn = (columnName: string) => + new EncryptedTextMatchColumn(columnName, TEXT_MATCH) + +export class EncryptedTextOrdOreColumn extends EncryptedV3Column< + typeof TEXT_ORD_ORE +> {} +export const encryptedTextOrdOreColumn = (columnName: string) => + new EncryptedTextOrdOreColumn(columnName, TEXT_ORD_ORE) + +export class EncryptedTextOrdColumn extends EncryptedV3Column< + typeof TEXT_ORD +> {} +export const encryptedTextOrdColumn = (columnName: string) => + new EncryptedTextOrdColumn(columnName, TEXT_ORD) + +// bool +export class EncryptedBoolColumn extends EncryptedV3Column<typeof BOOL> {} +export const encryptedBoolColumn = (columnName: string) => + new EncryptedBoolColumn(columnName, BOOL) + +// float4 +export class EncryptedFloat4Column extends EncryptedV3Column<typeof FLOAT4> {} +export const encryptedFloat4Column = (columnName: string) => + new EncryptedFloat4Column(columnName, FLOAT4) + +export class EncryptedFloat4EqColumn extends EncryptedV3Column< + typeof FLOAT4_EQ +> {} +export const encryptedFloat4EqColumn = (columnName: string) => + new EncryptedFloat4EqColumn(columnName, FLOAT4_EQ) + +export class EncryptedFloat4OrdOreColumn extends EncryptedV3Column< + typeof FLOAT4_ORD_ORE +> {} +export const encryptedFloat4OrdOreColumn = (columnName: string) => + new EncryptedFloat4OrdOreColumn(columnName, FLOAT4_ORD_ORE) + +export class EncryptedFloat4OrdColumn extends EncryptedV3Column< + typeof FLOAT4_ORD +> {} +export const encryptedFloat4OrdColumn = (columnName: string) => + new EncryptedFloat4OrdColumn(columnName, FLOAT4_ORD) + +// float8 +export class EncryptedFloat8Column extends EncryptedV3Column<typeof FLOAT8> {} +export const encryptedFloat8Column = (columnName: string) => + new EncryptedFloat8Column(columnName, FLOAT8) + +export class EncryptedFloat8EqColumn extends EncryptedV3Column< + typeof FLOAT8_EQ +> {} +export const encryptedFloat8EqColumn = (columnName: string) => + new EncryptedFloat8EqColumn(columnName, FLOAT8_EQ) + +export class EncryptedFloat8OrdOreColumn extends EncryptedV3Column< + typeof FLOAT8_ORD_ORE +> {} +export const encryptedFloat8OrdOreColumn = (columnName: string) => + new EncryptedFloat8OrdOreColumn(columnName, FLOAT8_ORD_ORE) + +export class EncryptedFloat8OrdColumn extends EncryptedV3Column< + typeof FLOAT8_ORD +> {} +export const encryptedFloat8OrdColumn = (columnName: string) => + new EncryptedFloat8OrdColumn(columnName, FLOAT8_ORD) + +/** + * Union of every v3 concrete column type. Used as the value type for v3 table + * columns so a table may mix any generated domains. + */ +export type AnyEncryptedV3Column = + | EncryptedInt4Column + | EncryptedInt4EqColumn + | EncryptedInt4OrdOreColumn + | EncryptedInt4OrdColumn + | EncryptedInt2Column + | EncryptedInt2EqColumn + | EncryptedInt2OrdOreColumn + | EncryptedInt2OrdColumn + | EncryptedDateColumn + | EncryptedDateEqColumn + | EncryptedDateOrdOreColumn + | EncryptedDateOrdColumn + | EncryptedTimestamptzColumn + | EncryptedTimestamptzEqColumn + | EncryptedTimestamptzOrdOreColumn + | EncryptedTimestamptzOrdColumn + | EncryptedNumericColumn + | EncryptedNumericEqColumn + | EncryptedNumericOrdOreColumn + | EncryptedNumericOrdColumn + | EncryptedTextColumn + | EncryptedTextEqColumn + | EncryptedTextMatchColumn + | EncryptedTextOrdOreColumn + | EncryptedTextOrdColumn + | EncryptedTextSearchColumn + | EncryptedBoolColumn + | EncryptedFloat4Column + | EncryptedFloat4EqColumn + | EncryptedFloat4OrdOreColumn + | EncryptedFloat4OrdColumn + | EncryptedFloat8Column + | EncryptedFloat8EqColumn + | EncryptedFloat8OrdOreColumn + | EncryptedFloat8OrdColumn + +/** + * Shape of v3 table columns: every value is a v3 concrete column builder. + * (Nested fields are deferred to later increments.) + */ +export type EncryptedV3TableColumn = { + [key: string]: AnyEncryptedV3Column +} + +interface TableDefinition { + tableName: string + columns: Record<string, ColumnSchema> +} + +/** + * A v3 encrypted table. Mirrors the v2 `EncryptedTable` but only accepts v3 + * column builders. Emits the same `{ tableName, columns }` definition shape. + */ +export class EncryptedTable<T extends EncryptedV3TableColumn> { + /** @internal Type-level brand so TypeScript can infer `T` from `EncryptedTable<T>`. */ + declare readonly _columnType: T + + constructor( + public readonly tableName: string, + public readonly columnBuilders: T, + ) {} + + build(): TableDefinition { + const builtColumns: Record<string, ColumnSchema> = {} + for (const builder of Object.values(this.columnBuilders)) { + // Key by the column's DB name (`getName()`), NOT the JS property name. + // `encrypt`/`decrypt` look columns up in the config by `column.getName()`, + // so a camelCase JS key mapping to a snake_case DB column (e.g. + // `createdOn: encryptedDateColumn('created_on')`) must register under + // `created_on` or the FFI reports "column not found in Encrypt config". + builtColumns[builder.getName()] = builder.build() + } + return { + tableName: this.tableName, + columns: builtColumns, + } + } + + /** + * Map each column's JS property name to its DB column name (`getName()`). + * The model path matches user models by property name but must address the + * encrypt config and FFI by DB name — `build()` keys columns by DB name, so + * the two only agree when property == name. This recovers the mapping that + * `build()` discards. + */ + buildColumnKeyMap(): Record<string, string> { + const map: Record<string, string> = {} + for (const [property, builder] of Object.entries(this.columnBuilders)) { + map[property] = builder.getName() + } + return map + } +} + +/** + * Own instance members of {@link EncryptedTable} that a column name must not + * shadow. Because {@link encryptedTable} copies column builders onto the + * instance for accessor access (`users.email`), a column named e.g. `build` + * would otherwise overwrite the method that {@link buildEncryptConfig} relies + * on. `_columnType` is a type-only `declare` (no runtime property) so it is + * listed explicitly here rather than caught by the `in` check below. + */ +const RESERVED_TABLE_KEYS = new Set([ + 'tableName', + 'columnBuilders', + '_columnType', + 'build', + 'buildColumnKeyMap', +]) + +/** + * Whether a column name would collide with a reserved property on the table + * object — either an own member ({@link RESERVED_TABLE_KEYS}) or any inherited + * `Object.prototype` member (`constructor`, `toString`, `valueOf`, + * `hasOwnProperty`, …). The `in` check covers the prototype chain so assigning + * the column as an own property can never shadow a prototype method/accessor. + */ +function isReservedTableKey(tableBuilder: object, colName: string): boolean { + return RESERVED_TABLE_KEYS.has(colName) || colName in tableBuilder +} + +/** + * Define a v3 encrypted table. Intentionally shadows the v2 `encryptedTable` + * name but lives on the `/v3` subpath — the importer picks the model by import + * path. The returned object is also a column accessor (`users.email`). + */ +export function encryptedTable<T extends EncryptedV3TableColumn>( + tableName: string, + columns: T, +): EncryptedTable<T> & T { + const tableBuilder = new EncryptedTable( + tableName, + columns, + ) as EncryptedTable<T> & T + + for (const [colName, colBuilder] of Object.entries(columns)) { + if (isReservedTableKey(tableBuilder, colName)) { + throw new Error( + `Column name "${colName}" collides with a reserved EncryptedTable property`, + ) + } + ;(tableBuilder as EncryptedV3TableColumn)[colName] = colBuilder + } + + return tableBuilder +} + +/** + * Build an `EncryptConfig` (`v: 1`) from one or more v3 tables. Emits the same + * shape as v2's `buildEncryptConfig`. + */ +export function buildEncryptConfig( + ...tables: Array<EncryptedTable<EncryptedV3TableColumn>> +): EncryptConfig { + const config: EncryptConfig = { + v: 1, + tables: {}, + } + + for (const tb of tables) { + const tableDef = tb.build() + // Config tables are keyed by name, so a duplicate would silently overwrite + // the earlier table. Fail loudly instead. (v3-only additive guard; v2's + // buildEncryptConfig keeps its existing silent-overwrite behavior.) + if (Object.hasOwn(config.tables, tableDef.tableName)) { + throw new Error( + `[schema/v3]: duplicate table name "${tableDef.tableName}" passed to buildEncryptConfig — each table must have a unique name`, + ) + } + config.tables[tableDef.tableName] = tableDef.columns + } + + return config +} + +/** Map a domain's {@link PlaintextKind} to its TypeScript plaintext type. */ +type PlaintextFromKind<K extends PlaintextKind> = K extends 'string' + ? string + : K extends 'number' + ? number + : K extends 'boolean' + ? boolean + : K extends 'date' + ? Date + : never + +/** + * The plaintext type for a single v3 column, read from the literal domain + * definition carried on the base class's private field. This is stable across + * empty subclasses that share the same base generic — a subclass-name + * conditional would collapse because those subclasses are structurally + * assignable to one another. + */ +export type PlaintextForColumn<C> = + C extends EncryptedV3Column<infer D> ? PlaintextFromKind<D['castAs']> : never + +/** + * Infer the plaintext (decrypted) shape from a v3 table schema. Each column maps + * to the TypeScript type of its domain's `castAs` kind. + */ +export type InferPlaintext<T extends EncryptedTable<EncryptedV3TableColumn>> = + T extends EncryptedTable<infer C> + ? { [K in keyof C]: PlaintextForColumn<C[K]> } + : never + +/** + * Infer the encrypted shape from a v3 table schema. See {@link InferPlaintext} + * for why no key-remap filter is needed in the flat single-type model. + */ +export type InferEncrypted<T extends EncryptedTable<EncryptedV3TableColumn>> = + T extends EncryptedTable<infer C> ? { [K in keyof C]: Encrypted } : never + +// --------------------------------------------------------------------------- +// Typed-client surface helpers (@cipherstash/stack/v3) +// --------------------------------------------------------------------------- + +/** + * The user-facing `queryType` names a v3 column supports, derived 1:1 from its + * capability flags. Resolves to `never` for a storage-only column (all flags + * `false`) and for any non-v3 value. The names mirror the {@link QueryCapabilities} + * keys and the first three {@link import('@/types').QueryTypeName} members. + */ +export type QueryTypesForColumn<C> = + C extends EncryptedV3Column<infer D> + ? + | (D['capabilities']['equality'] extends true ? 'equality' : never) + | (D['capabilities']['orderAndRange'] extends true + ? 'orderAndRange' + : never) + | (D['capabilities']['freeTextSearch'] extends true + ? 'freeTextSearch' + : never) + : never + +/** Any v3 table, regardless of its column map. */ +export type AnyV3Table = EncryptedTable<EncryptedV3TableColumn> + +/** Union of the concrete column builders declared on a v3 table. */ +export type ColumnsOf<T extends AnyV3Table> = + T extends EncryptedTable<infer C> ? C[keyof C] : never + +/** + * Union of the *queryable* column builders on a v3 table. Storage-only columns + * (whose {@link QueryTypesForColumn} is `never`) are filtered out, so they can't + * be passed to a query method. + */ +export type QueryableColumnsOf<T extends AnyV3Table> = + T extends EncryptedTable<infer C> + ? { + [K in keyof C]: [QueryTypesForColumn<C[K]>] extends [never] + ? never + : C[K] + }[keyof C] + : never + +/** + * The accepted input model for {@link import('@/encryption/v3').TypedEncryptionClient.encryptModel}. + * `T` is inferred from the argument: keys that name a schema column are pinned to + * the column's plaintext type (nullable if the field is nullable), so a wrong-typed + * field fails assignability; all other keys pass through unchanged. + */ +export type V3ModelInput<Table extends AnyV3Table, T> = { + [K in keyof T]: K extends keyof InferPlaintext<Table> + ? null extends T[K] + ? InferPlaintext<Table>[K] | null + : InferPlaintext<Table>[K] + : T[K] +} + +/** The encrypted result model: schema columns become `Encrypted`, others pass through. */ +export type V3EncryptedModel<Table extends AnyV3Table, T> = { + [K in keyof T]: K extends keyof InferPlaintext<Table> + ? null extends T[K] + ? Encrypted | null + : Encrypted + : T[K] +} + +/** The decrypted result model: schema columns become their plaintext type, others pass through. */ +export type V3DecryptedModel<Table extends AnyV3Table, T> = { + [K in keyof T]: K extends keyof InferPlaintext<Table> + ? null extends T[K] + ? InferPlaintext<Table>[K] | null + : InferPlaintext<Table>[K] + : T[K] +} diff --git a/packages/stack/src/types.ts b/packages/stack/src/types.ts index a284596b..1a1dad06 100644 --- a/packages/stack/src/types.ts +++ b/packages/stack/src/types.ts @@ -7,9 +7,9 @@ import type { QueryOpName, } from '@cipherstash/protect-ffi' import type { + ColumnSchema, EncryptedColumn, EncryptedField, - EncryptedTable, EncryptedTableColumn, // Imported type-only for the TSDoc {@link} references in the comments below. encryptedColumn, @@ -62,6 +62,26 @@ export type Encrypted = CipherStashEncrypted * storage-shaped {@link Encrypted} payload instead. */ export type EncryptedQuery = CipherStashEncryptedQuery +/** + * Plaintext values the SDK accepts for encryption. + * + * Widens the FFI's `JsPlaintext` (`string | number | boolean | + * Record<string, unknown> | JsPlaintext[]`) with `Date`. `Date` is a supported + * cast target that is omitted from the FFI's `JsPlaintext` INPUT union, but it + * serializes at the boundary via `toJSON` (ISO string), so it is accepted on the + * way in. + * + * `bigint` is intentionally NOT included: the native `@cipherstash/protect-ffi` + * build cannot marshal a JS `bigint` (V8 throws "Do not know how to serialize a + * BigInt") and rejects a `string` for a `big_int` column. The v3 int8 domains + * are therefore omitted from the SDK entirely (see `schema/v3`) until the FFI + * supports lossless bigint I/O; `bigint` returns here alongside them. + * + * When the upstream FFI `JsPlaintext` is corrected to include `Date`, the `Date` + * arm can collapse back into `JsPlaintext`. + */ +export type Plaintext = JsPlaintext | Date + // --------------------------------------------------------------------------- // Client configuration // --------------------------------------------------------------------------- @@ -131,11 +151,95 @@ export type ClientConfig = { type AtLeastOneCsTable<T> = [T, ...T[]] +/** Structural contract for a column builder the client can consume for STORAGE + * (`encrypt`). Satisfied by v2 `EncryptedColumn` / `EncryptedField` AND v3 + * `EncryptedTextSearchColumn` — fields ARE encryptable, so this stays wide. */ +export interface BuildableColumn { + getName(): string + build(): ColumnSchema +} + +/** Structural contract for a column the client can consume for QUERIES + * (`encryptQuery` / search terms). Narrower than `BuildableColumn`: it must + * EXCLUDE non-queryable `EncryptedField` (a field has no indexes). A v2 + * `EncryptedColumn` qualifies via the nominal arm; a v3 queryable concrete + * type qualifies via the `getEqlType()` structural arm; `EncryptedField` (no + * `getEqlType`, not an `EncryptedColumn`) is rejected. */ +export interface BuildableV3QueryableColumn extends BuildableColumn { + getEqlType(): string + getQueryCapabilities(): { + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean + } + isQueryable(): true +} + +export type BuildableQueryColumn = EncryptedColumn | BuildableV3QueryableColumn + +/** Structural contract for a table builder the client can consume. Satisfied by + * v2 and v3 `EncryptedTable` alike. */ +export interface BuildableTable { + tableName: string + build(): { tableName: string; columns: Record<string, ColumnSchema> } + /** + * Optional map from a model field's JS property name to its encrypt-config + * column name (the DB name). Present when the two can differ — v3 tables key + * their config by DB name (`column.getName()`) while models are written with + * JS property keys, so the model path must match by property but address the + * FFI/config by DB name. + * + * Absent on v2 tables, whose `build()` already keys columns by the JS property + * name; the model path then matches and addresses by that same key. + */ + buildColumnKeyMap?(): Record<string, string> +} + export type EncryptionClientConfig = { - schemas: AtLeastOneCsTable<EncryptedTable<EncryptedTableColumn>> + schemas: AtLeastOneCsTable<BuildableTable> config?: ClientConfig } +/** + * The literal column map of a buildable table, read from its type-level + * `_columnType` brand. Both v2 and v3 `EncryptedTable` carry this brand, so this + * recovers the literal column keys structurally. + * + * This deliberately uses the `_columnType` brand rather than `build().columns`: + * `BuildableTable.build()` is typed to return `Record<string, ColumnSchema>`, + * which erases the literal keys and would mark EVERY model field as encrypted. + * + * The fallbacks resolve to `Record<never, never>` (a no-key type), NOT `never`: + * a value typed as the bare structural `BuildableTable` carries no `_columnType` + * brand, and `keyof never` is `string | number | symbol` — which would wrongly + * mark EVERY model field as encrypted. `keyof Record<never, never>` is `never`, + * so `EncryptedFromBuildableTable` degrades gracefully to the model unchanged. + */ +export type BuildableTableColumns<T extends BuildableTable> = T extends { + readonly _columnType: infer C +} + ? C extends Record<string, unknown> + ? C + : Record<never, never> + : Record<never, never> + +/** + * Maps a plaintext model type to its encrypted form using a buildable table. + * + * Fields whose keys match a column defined in `Table` (via its `_columnType` + * brand) become `Encrypted` (`Encrypted | null` when the source field is + * nullable); all other fields retain their original types from `T`. Works for + * both v2 and v3 tables. See {@link EncryptedFromSchema} for the v2-specific + * variant retained for backward compatibility. + */ +export type EncryptedFromBuildableTable<T, Table extends BuildableTable> = { + [K in keyof T]: [K] extends [keyof BuildableTableColumns<Table>] + ? null extends T[K] + ? Encrypted | null + : Encrypted + : T[K] +} + // --------------------------------------------------------------------------- // Encrypt / decrypt operation options and results // --------------------------------------------------------------------------- @@ -147,8 +251,8 @@ export type EncryptionClientConfig = { */ export type EncryptOptions = { /** The column or nested field to encrypt into. From {@link EncryptedColumn} or {@link EncryptedField}. */ - column: EncryptedColumn | EncryptedField - table: EncryptedTable<EncryptedTableColumn> + column: BuildableColumn // storage: fields are encryptable, so stays wide + table: BuildableTable } /** Format for encrypted query/search term return values */ @@ -158,9 +262,9 @@ export type EncryptedReturnType = | 'escaped-composite-literal' export type SearchTerm = { - value: JsPlaintext - column: EncryptedColumn - table: EncryptedTable<EncryptedTableColumn> + value: Plaintext + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable returnType?: EncryptedReturnType } @@ -241,7 +345,7 @@ export type EncryptedFromSchema<T, S extends EncryptedTableColumn> = { // position-stable output. export type BulkEncryptPayload = Array<{ id?: string - plaintext: JsPlaintext | null + plaintext: Plaintext | null }> export type BulkEncryptedData = Array<{ id?: string; data: Encrypted | null }> @@ -310,8 +414,8 @@ export const queryTypeToQueryOp: Partial<Record<QueryTypeName, QueryOpName>> = { /** @internal */ export type QueryTermBase = { - column: EncryptedColumn - table: EncryptedTable<EncryptedTableColumn> + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable queryType?: QueryTypeName returnType?: EncryptedReturnType } @@ -319,5 +423,5 @@ export type QueryTermBase = { export type EncryptQueryOptions = QueryTermBase export type ScalarQueryTerm = QueryTermBase & { - value: JsPlaintext + value: Plaintext } diff --git a/packages/stack/src/wasm-inline.ts b/packages/stack/src/wasm-inline.ts index ce47233e..9fc36a4b 100644 --- a/packages/stack/src/wasm-inline.ts +++ b/packages/stack/src/wasm-inline.ts @@ -71,8 +71,6 @@ import { buildEncryptConfig, type CastAs, type EncryptConfig, - EncryptedColumn, - EncryptedField, type EncryptedTable, type EncryptedTableColumn, encryptConfigSchema, @@ -355,12 +353,26 @@ export function normalizeCastAs(config: EncryptConfig): unknown { return { ...config, tables } } -function getColumnName(col: EncryptOptions['column']): string { - if (col instanceof EncryptedColumn || col instanceof EncryptedField) { +/** + * Resolve a column's name structurally. Accepts any column builder exposing + * `getName()` — v2 `EncryptedColumn` / `EncryptedField` AND v3 column builders + * (e.g. `EncryptedTextSearchColumn`) alike — matching the structural + * `BuildableColumn` contract that `EncryptOptions.column` was widened to. + * + * An `instanceof EncryptedColumn || EncryptedField` gate would type-check after + * the widening but throw at runtime for a v3 column, breaking the type promise; + * resolving the name structurally keeps the wasm-inline encrypt entry honest. + * The `typeof` check still fails loudly for plain JS callers passing a value + * that is not a column builder. + * + * @internal exported for unit-test coverage. + */ +export function getColumnName(col: EncryptOptions['column']): string { + if (typeof col?.getName === 'function') { return col.getName() } throw new Error( - '[encryption]: opts.column must be an EncryptedColumn or EncryptedField', + '[encryption]: opts.column must be a column builder exposing getName()', ) } @@ -387,12 +399,16 @@ export function resolveStrategy(cfg: WasmClientConfig): WasmAuthStrategy { if (cfg.strategy) return cfg.strategy // No strategy → the access-key arm, where `workspaceCrn` and `accessKey` // are both required (and so present at runtime); the union widens their - // static types to `string | undefined`, hence the casts. + // static types to `string | undefined`, hence the casts. Guard at runtime + // so plain JS / Deno callers that bypass the compile-time union fail loudly + // instead of forwarding `undefined` into `AccessKeyStrategy.create`. + if (!cfg.workspaceCrn || !cfg.accessKey) { + throw new Error( + '[encryption]: `config.workspaceCrn` and `config.accessKey` are required when `config.strategy` is not provided.', + ) + } // `AccessKeyStrategy.create` takes the full workspace CRN — the region is // derived from it inside `@cipherstash/auth`, so the CRN stays the single // source of truth with no manual region split. - return AccessKeyStrategy.create( - cfg.workspaceCrn as string, - cfg.accessKey as string, - ) + return AccessKeyStrategy.create(cfg.workspaceCrn, cfg.accessKey) } diff --git a/packages/stack/tsconfig.typecheck.json b/packages/stack/tsconfig.typecheck.json new file mode 100644 index 00000000..9d06679f --- /dev/null +++ b/packages/stack/tsconfig.typecheck.json @@ -0,0 +1,4 @@ +{ + "extends": "./tsconfig.json", + "include": ["__tests__/**/*.test-d.ts"] +} diff --git a/packages/stack/tsup.config.ts b/packages/stack/tsup.config.ts index 98cd6b51..85c88212 100644 --- a/packages/stack/tsup.config.ts +++ b/packages/stack/tsup.config.ts @@ -15,10 +15,12 @@ export default defineConfig([ 'src/identity/index.ts', 'src/secrets/index.ts', 'src/schema/index.ts', + 'src/schema/v3/index.ts', 'src/drizzle/index.ts', 'src/dynamodb/index.ts', 'src/supabase/index.ts', 'src/encryption/index.ts', + 'src/encryption/v3.ts', 'src/errors/index.ts', ], format: ['cjs', 'esm'], diff --git a/packages/stack/vitest.config.ts b/packages/stack/vitest.config.ts index 64a1542f..c4b1da04 100644 --- a/packages/stack/vitest.config.ts +++ b/packages/stack/vitest.config.ts @@ -5,6 +5,28 @@ export default defineConfig({ resolve: { alias: { '@/': resolve(__dirname, './src') + '/', + // The installed `@cipherstash/{protect-ffi,auth}` only export `.`; their + // `/wasm-inline` subpaths (imported by `src/wasm-inline.ts`) are not + // resolvable by Vitest. Alias them to local stubs so unit tests that only + // exercise pure helpers can load the module. Tests needing real WASM + // behaviour mock these specifiers explicitly. + '@cipherstash/protect-ffi/wasm-inline': resolve( + __dirname, + './__tests__/helpers/stub-protect-ffi-wasm-inline.ts', + ), + '@cipherstash/auth/wasm-inline': resolve( + __dirname, + './__tests__/helpers/stub-auth-wasm-inline.ts', + ), + }, + }, + test: { + typecheck: { + // Scoped tsconfig keeps the 124 pre-existing wasm-inline typecheck errors + // out of scope (tracked as a follow-up). Run via the `test:types` script + // with `--typecheck.only` so the runtime suites do NOT also execute. + tsconfig: './tsconfig.typecheck.json', + include: ['__tests__/**/*.test-d.ts'], }, }, }) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 3297d549..a2d4c85b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -588,6 +588,9 @@ importers: execa: specifier: ^9.5.2 version: 9.6.1 + fta-cli: + specifier: 3.0.0 + version: 3.0.0 json-schema-to-typescript: specifier: ^15.0.2 version: 15.0.4 @@ -3013,6 +3016,10 @@ packages: engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] + fta-cli@3.0.0: + resolution: {integrity: sha512-SBmoqIwbN7PLDmwmrPgjr6Z6/S9jPhNz5TCPmEVFkIaeloc/T2WXLeeXqhG1+C0UQxpOfGrC7CUb4friqbc2kQ==} + hasBin: true + function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} @@ -6223,6 +6230,8 @@ snapshots: fsevents@2.3.3: optional: true + fta-cli@3.0.0: {} + function-bind@1.1.2: {} gel@2.2.0: